直接初始化与复制初始化

C++ Primer：直接初始化不一定要调用复制构造函数，而复制初始化一定要调用复制构造函数。

一、通常的误解

为了把问题说清楚，还是从代码上来解释比较容易让人明白，请看下面的代码：

#include <iostream>
#include <cstring>
using namespace std;
class ClassTest
{
    public:
        ClassTest()
        {
            c[0] = '\0';
            cout<<"ClassTest()"<<endl;
        }
        ClassTest& operator=(const ClassTest &ct)
        {
            strcpy(c, ct.c);
            cout<<"ClassTest& operator=(const ClassTest &ct)"<<endl;
            return *this;
        }
        ClassTest(const char *pc)
        {
            strcpy(c, pc);
            cout<<"ClassTest (const char *pc)"<<endl;
        }
        // private:
        ClassTest(const ClassTest& ct)
        {
            strcpy(c, ct.c);
            cout<<"ClassTest(const ClassTest& ct)"<<endl;
        }
    private:
        char c[256];
};

int main()
{
    cout<<"ct1: ";
    ClassTest ct1("ab");//直接初始化
    cout<<"ct2: ";
    ClassTest ct2 = "ab";//复制初始化
    cout<<"ct3: ";
    ClassTest ct3 = ct1;//复制初始化
    cout<<"ct4: ";
    ClassTest ct4(ct1);//直接初始化（直接初始化不一定要调用复制构造函数，这里调用了，而复制初始化一定要调用复制构造函数）
    cout<<"ct5: ";
    ClassTest ct5 = ClassTest();//复制初始化
    return 0;
}

输出结果为：

图1 执行结果

从输出的结果，我们可以知道对象的构造到底调用了哪些函数，从ct1与ct2、ct3与ct4的比较中可以看出，ct1与ct2对象的构建调用的都是同一个函数——ClassTest(const char *pc)，同样道理，ct3与ct4调用的也是同一个函数——ClassTest(const ClassTest& ct)，而ct5则直接调用了默认构造函数。

于是，很多人就认为ClassTest ct1("ab");等价于ClassTest ct2 = "ab";，而ClassTest ct3 = ct1;也等价于ClassTest ct4(ct1);而且他们都没有调用赋值操作函数，所以它们都是直接初始化，然而事实是否真的如你所想的那样呢？答案显然不是。

二、到底谁欺骗了我们

很多时候，自己的眼睛往往会欺骗你自己，这里就是一个例子，正是你的眼睛欺骗了你。为什么会这样？其中的原因在谈优化时的补充中也有说明，就是因为编译会帮你做很多你看不到，你也不知道的优化，你看到的结果，正是编译器做了优化后的代码的运行结果，并不是你的代码的真正运行结果。

你也许不相信我所说的，那么你可以把类中的复制函数函数中面注释起来的那行取消注释，让复制构造函数成为私有函数再编译运行这个程序，看看有什么结果发生。

很明显，发生了编译错误，从上面的运行结果，你可能会认为是因为ct3和ct4在构建过程中用到了复制构造函数——ClassTest(const ClassTest& ct)，而现在它变成了私有函数，不能在类的外面使用，所以出现了编译错误，但是你也可以把ct3和ct4的函数语句注释起来，如下所示：

int main()
{
    cout<<"ct1: ";
    ClassTest ct1("ab");
    cout<<"ct2: ";
    ClassTest ct2 = "ab";
    // cout<<"ct3: ";
    // ClassTest ct3 = ct1;
    // cout<<"ct4: ";
    // ClassTest ct4(ct1);
    cout<<"ct5: ";
    ClassTest ct5 = ClassTest();
    return 0;
}

然而你还是非常遗憾地发现，还是没有编译通过。这是为什么呢？从上面的语句和之前的运行结果来看，的确是已经没有调用复制构造函数了，为什么还是编译错误呢？

经过实验，main函数只有这样才能通过编译：

int main()
{
    cout<<"ct1: ";
    ClassTestct1("ab");
    return0;
}

在这里我们可以看到，原来是复制构造函数欺骗了我们。

三、揭开真相

看到这里，你可能已经大惊失色，下面就让我来揭开这个真相吧！

还是那一句，什么是直接初始化，而什么又是复制初始化呢？

简单点来说，就是定义对象时的写法不一样，一个用括号，如ClassTest ct1("ab")，而一个用等号，如ClassTest ct2 = "ab"。

但是从本质来说，它们却有本质的不同：直接初始化直接调用与实参匹配的构造函数，复制初始化总是调用复制构造函数。复制初始化首先使用指定构造函数创建一个临时对象，然后用复制构造函数将那个临时对象复制到正在创建的对象。所以当复制构造函数被声明为私有时，所有的复制初始化都不能使用。

现在我们再来看回main函数中的语句，

1、ClassTest ct1("ab");这条语句属于直接初始化，它不需要调用复制构造函数，直接调用构造函数ClassTest(const char *pc)，所以当复制构造函数变为私有时，它还是能直接执行的。

2、ClassTest ct2 = "ab";这条语句为复制初始化，它首先调用构造函数ClassTest(const char *pc)函数创建一个临时对象，然后调用复制构造函数，把这个临时对象作为参数，构造对象ct2；所以当复制构造函数变为私有时，该语句不能编译通过。

3、ClassTest ct3 = ct1;这条语句为复制初始化，因为ct1本来已经存在，所以不需要调用相关的构造函数，而直接调用复制构造函数，把它值复制给对象ct3；所以当复制构造函数变为私有时，该语句不能编译通过。

4、ClassTest ct4(ct1)；这条语句为直接初始化，因为ct1本来已经存在，直接调用复制构造函数，生成对象ct3的副本对象ct4。所以当复制构造函数变为私有时，该语句不能编译通过。

注：第4个对象ct4与第3个对象ct3的创建所调用的函数是一样的，但是本人却认为，调用复制函数的原因却有所不同。因为直接初始化是根据参数来调用构造函数的，如ClassTest ct4（ct1），它是根据括号中的参数（一个本类的对象），来直接确定为调用复制构造函数ClassTest(const ClassTest& ct)，这跟函数重载时，会根据函数调用时的参数来调用相应的函数是一个道理；而对于ct3则不同，它的调用并不是像ct4时那样，是根据参数来确定要调用复制构造函数的，它只是因为初始化必然要调用复制构造函数而已。它理应要创建一个临时对象，但只是这个对象却已经存在，所以就省去了这一步，然后直接调用复制构造函数，因为复制初始化必然要调用复制构造函数，所以ct3的创建仍是复制初始化。

5、ClassTest ct5 = ClassTest();这条语句为复制初始化，首先调用默认构造函数产生一个临时对象，然后调用复制构造函数，把这个临时对象作为参数，构造对象ct5。所以当复制构造函数变为私有时，该语句不能编译通过。

四、补充

上面讨论的都是直接初始化和复制初始化构造，都不会走到“ClassTest& operator=(const ClassTest &ct)”，因为“operator =”不属于构造函数，它的名字叫“copy assignment操作符”。

为了进行验证做如下代码修改，请查看执行结果：

int main()
{
    cout<<"ct1: ";
    ClassTest ct1("ab");//直接初始化
    cout<<"ct2: ";
    ClassTest ct2 = "ab";//复制初始化
    cout<<"ct3: ";
    ClassTest ct3 = ct1;//复制初始化
    cout<<"ct4: ";
    ClassTest ct4(ct1);//直接初始化
    cout<<"ct5: ";
    ClassTest ct5 = ClassTest();//复制初始化
    cout<<"ct5 = ct1: ";
    ct5 = ct1;//copy assignme操作符
    return 0;
}

图2 执行结果