复制构造函数和赋值运算符

Question

我编写了以下程序来测试何时调用复制构造函数以及何时调用赋值运算符：

#include 

class Test
{
public:
    Test() :
        iItem (0)
    {
        std::cout << "This is the default ctor" << std::endl;
    }

    Test (const Test& t) :
        iItem (t.iItem)

    {
        std::cout << "This is the copy ctor" << std::endl;
    }

    ~Test()
    {
        std::cout << "This is the dtor" << std::endl;
    }

    const Test& operator=(const Test& t)
    {
        iItem = t.iItem;    
        std::cout << "This is the assignment operator" << std::endl;
        return *this;
    }

private:
    int iItem;
};

int main()
{
    {
        Test t1;
        Test t2 = t1;
    }
    {
        Test t1;
        Test t2 (t1);
    }
    {
        Test t1;
        Test t2;
        t2 = t1;
    }
}

这会产生以下输出（仅添加空行以使其更易于理解）：

doronw@DW01:~$ ./test
This is the default ctor
This is the copy ctor
This is the dtor
This is the dtor

This is the default ctor
This is the copy ctor
This is the dtor
This is the dtor

This is the default ctor
This is the default ctor
This is the assignment operator
This is the dtor
This is the dtor

第二个和第三个set 的行为符合预期，但在第一个 set 中，即使使用了赋值运算符，也会调用复制构造函数。

这种行为是 C++ 标准的一部分还是只是一个聪明的编译器优化（我正在使用 gcc 4.4.1）

Answer 1

第一个测试用例中没有使用赋值运算符。它只是使用称为“复制初始化”的初始化形式。复制初始化在初始化对象时不考虑显式构造函数。

struct A {
  A();

  // explicit copy constructor
  explicit A(A const&);

  // explicit constructor
  explicit A(int);

  // non-explicit "converting" constructor
  A(char const*c);
};

A a;
A b = a; // fail
A b1(a); // succeeds, "direct initialization"

A c = 1; // fail, no converting constructor found
A d(1); // succeeds

A e = "hello"; // succeeds, converting constructor used

复制初始化用于与隐式转换相对应的情况，其中不显式启动转换，如函数参数传递和从函数返回。

Answer 2

C++ 标准 8.5/12

初始化发生在
参数传递、函数返回、
抛出异常（15.1），处理
例外（15.3），以及
大括号括起来的初始值设定项列表
(8.5.1) 称为复制初始化
且等价于以下形式

T x = a;

new 中发生的初始化
表达式 (5.3.4)、static_cast
表达式 (5.2.9)，函数式
符号类型转换（5.2.3），以及
基类和成员初始值设定项 (12.6.2)
称为直接初始化，并且是
相当于表格

<前><代码>T x(a);

Answer 3

您的第一组是根据 C++ 标准，而不是由于某些优化。

第 12.8 节 ([class.copy]) C++ 标准 给出了类似的示例：

class X {
    // ...
public:
    X(int);
    X(const X&, int = 1);
};

X a(1);     // calls X(int);
X b(a, 0);  // calls X(const X&, int);
X c = b;    // calls X(const X&, int);

最后一行将是与您的情况匹配的行。