临时构造函数和复制构造函数

Question

在下面的程序中，我尝试使用复制向量进行实验，有一点不清楚，当函数 f( ) 返回时，它应该使用复制向量为 < code>h2，但是我猜这是通过临时对象完成的，该对象使用对象的构造函数，然后进行复制，但是销毁输出表明我在这个推理上是错误的...需要一些澄清这个问题；）

#include <fstream>
#include <string>
using namespace std;
ofstream out("HowMany2.out");

class HowMany2 {
  string name; // Object identifier
  static int objectCount;
public:
  HowMany2(const string& id = "") : name(id) {
    ++objectCount;
    print("HowMany2()");
  }
  ~HowMany2() {
    --objectCount;
    print("~HowMany2()");
  }
  // The copy-constructor:
  HowMany2(const HowMany2& h) : name(h.name) {
    name += " copy";
    ++objectCount;
    print("HowMany2(const HowMany2&)");
  }
  void print(const string& msg = "") const {
    if(msg.size() != 0) 
      out << msg << endl;
    out << '\t' << name << ": "
        << "objectCount = "
        << objectCount << endl;
  }
};

int HowMany2::objectCount = 0;

// Pass and return BY VALUE:
HowMany2 f(HowMany2 x) {
  x.print("x argument inside f()");
  out << "Returning from f()" << endl;
  return x;
}

int main() {
  HowMany2 h("h");
  out << "Entering f()" << endl;
  HowMany2 h2 = f(h);
} 

输出

HowMany2()
  h: objectCount = 1
Entering f()
HowMany2(const HowMany2&)
  h copy: objectCount = 2
x argument inside f()
  h copy: objectCount = 2
Returning from f()
HowMany2(const HowMany2&)
  h copy copy: objectCount = 3
~HowMany2()
  h copy: objectCount = 2  // Confused here !!!! why not h copy copy
~HowMany2()
  h copy copy: objectCount = 1
~HowMany2()
  h: objectCount = 0

Answer 1

h copy copy 基本上是这一行中的 h2：

HowMany2 h2 = f(h);

当您从 main 退出时，它会被破坏。

h copy是f的参数，当f返回时它被破坏。由于f在main之前返回，因此h copy在h copy copy之前被破坏。

请注意，RVO（返回值优化）是由编译器完成的。此代码中没有创建临时对象。实际上，根据编译器的不同，这段代码可能会输出不同的结果。编译器可以在此代码中自由调用 1 或 2 次复制构造函数。 （在这种情况下也许零也是可能的，但我不知道如何证明它的合理性。）

编辑：您的代码是由编译器实现的，如下所示（伪代码）：

void f(HowMany2 *result, HowMany2* xptr) {
  HowMany2 x(*xptr); // local copy

  x.print("x argument inside f()");
  out << "Returning from f()" << endl;

  new(result) HowMany2(x); // copy the return value

  x.~HowMany(); // destroy local copy
}

int main() {
  HowMany2 h("h");
  out << "Entering f()" << endl;
  HowMany2 h2; // not initialized
  f(&h2, &h);
  h2.~HowMany2();
} 

Answer 2

在那个“混乱”点，函数 f 的临时本地对象在返回以在函数外部创建副本（“h copy copy”）后被销毁（“h copy”）。然后，函数外部的对象按照创建时的相反顺序被销毁：复制的对象（“h copy copy”），最后是原始对象（“h”）。

Answer 3

f() 的返回值正在执行复制构造回到 main。
结果将值放入变量 h2 中。

因此，函数中的参数x首先被销毁（因为它离开函数）。
然后h2，然后h，因为主函数退出并且它的局部变量被销毁。

~HowMany2()
  h copy: objectCount = 2          // destruction of x
~HowMany2()
  h copy copy: objectCount = 1     // destruction of h2
~HowMany2()
  h: objectCount = 0               // festruction of h

如果你想真正被吓坏。将 gcc 上的优化转为 full -O3 或在 VisStudio 中以发布模式构建。查看输出有何不同。