为什么在这段代码中使用复制因子？

Question

class A
{
 public:
  A(const int n_);
  A(const A& that_);
  A& operator=(const A& that_);
};

A::A(const int n_)
{ cout << "A::A(int), n_=" << n_ << endl; }

A::A(const A& that_)    // This is line 21
{ cout << "A::A(const A&)" << endl; }

A& A::operator=(const A& that_)
{ cout << "A::operator=(const A&)" << endl; }

int foo(const A& a_)
{ return 20; }

int main()
{
  A a(foo(A(10)));    // This is line 38
  return 0;
}

执行这段代码给出o/p：

A::A(int)，n_=10
A::A(int)，n_=20

显然复制构造函数从未被调用。

class A
{
 public:
  A(const int n_);
  A& operator=(const A& that_);
 private:
  A(const A& that_);
};

但是，如果我们将其设为私有，则会出现以下编译错误：

Test.cpp：在函数“int main()”中：
Test.cpp:21: 错误：'A::A(const A&)' 是私有的
Test.cpp：38：错误：在此上下文中

为什么编译器在实际不使用复制构造函数时会抱怨？
我使用的是 gcc 版本 4.1.2 20070925 (Red Hat 4.1.2-33)

Answer 1

不使用复制构造函数，但为了编译代码，复制构造函数需要可访问。

编辑：Comeau C++ 编译器报告以下内容：

Comeau C/C++ 4.3.10.1 (Oct  6 2008 11:28:09) for ONLINE_EVALUATION_BETA2
Copyright 1988-2008 Comeau Computing.  All rights reserved.
MODE:strict errors C++ noC++0x_extensions

"ComeauTest.c", line 38: error: "A::A(const A &)" (declared at line 17), required
          for copy that was eliminated, is inaccessible
    A a(foo(A(10)));    // This is line 38
            ^

1 error detected in the compilation of "ComeauTest.c".

请注意，如果启用了 C++0x 扩展，则它可以在 Comeau C++ 编译器中正常编译。

Answer 2

一般来说，您不应该担心复制构造函数是否以及何时被调用。 C++ 标准对于何时删除或添加对复制构造函数的调用相当宽松。 如果您的类在逻辑上需要它，则提供它（并且不要忘记析构函数和赋值运算符）是明智的规则。

Answer 3

调用时：

foo( A(10) );

在调用的生命周期内创建临时对象。 正在使用复制构造函数来填充数据。 执行调用后，临时对象将被删除。

调用时：

{ 
  A original(10);
  foo( original ); 
}

退出块后原始数据被丢弃。 它可以安全地用作参数。

为了获得最佳速度，请使用编译器在优化期间将丢弃的临时变量通过引用传递对象。

Answer 4

核心缺陷 391 解释了该问题。

基本上，当前的 C++ 标准要求在将类类型的临时值传递给 const 引用时提供可用的复制构造函数。

此要求将在 C++0x 中删除。

需要复制构造函数背后的逻辑来自这种情况：

C f();
const C& r = f(); // a copy is generated for r to refer to

Answer 5

2003 年标准第 §12.2/1 条规定：

即使创建
避免临时对象（12.8），
所有语义限制必须是
如同临时物品一样受到尊重
被创建。 [示例：即使
复制构造函数没有被调用，全部
语义限制，例如
可访问性（第 11 条），应
使满意。 ]

周围还有类似的例子。 据我所知，编译器可以自由地生成临时文件或优化它们。

Answer 6

据我所知，您没有在任何地方使用复制构造函数。 在语句 foo(A(10)) 中，您创建了 A 类的临时对象，并将其作为常量引用传递给 foo。 foo 返回一个整数，用于构造对象a。 因此，我不知道复制构造函数在哪里参与其中，也不知道 NRVO 是如何出现的。 另外，我通过将复制构造函数设置为私有来编译以下代码，并且它在 VS2008 中编译良好。

using namespace std;

class A
{
 public:
  A(const int n_);
 private:
  A(const A& that_);
  A& operator=(const A& that_);
};

A::A(const int n_)
{ cout << "A::A(int), n_=" << n_ << endl; }

A::A(const A& that_)    // This is line 21
{ cout << "A::A(const A&)" << endl; }

A& A::operator=(const A& that_)
{ 
    cout << "A::operator=(const A&)" << endl; 
    return *this;
}

int foo(const A& a_)
{ return 20; }


int main(int argc,char *argv[])
{
   A a(foo(A(10)));    // This is line 38
  return 0;

}   

Answer 7

另一句话：编译器在使用临时变量时会做不同的事情。 所以这不是关于复制构造函数，而是关于中间临时变量。

A original(10);
foo( original ); // does compile
foo( A(10) ); // doesn't compile - needs a copy constructor

Answer 8

在表达式中：

A a(foo(A(10)));

子表达式 A(10) 的结果是 A 类型的右值。 （5.2.3 [expr.type.conv]）

当从右值初始化常量引用时，编译器可以从右值创建一个临时变量并将其绑定到引用。 即使选择不这样做，复制构造函数也必须是可访问的。 （8.5.3 [decl.init.ref]）如果从强制直接绑定的引用兼容左值初始化引用，则情况不会如此。

由于 foo 通过引用而不是值获取其参数，因此参数初始化本身不需要强制复制。

foo 返回一个 int，因此这里没有 A 的副本。

a 是直接从 foo 返回的 int 初始化的，因此这里没有 A 的副本。