OOP-对象初始化

空间是进了大括号就分配了，构造函数是到了那行才运行

int a[5] = {1, 2, 3, 4, 5};
int b[6] = {5} //b[0] = 5 其他为0
struct X
{
    int i;
    char c;
    float f;
};
X x1 = {1, 'c', 2.2}; //结构体的初始化
X x2[3] = {{1, 'a', 1.1}, {2, 'b', 2.2}};
struct Y
{
    float f;
    int i;
    Y(int a);
};
Y y1[] = {Y(1), Y(2), Y(3)};
Y y2[2] = {Y(1)}; //错误的原因是，默认y2[1]的构造函数是无参数的，所以编译找不到构造函数，如果有了自己写的构造函数，默认无参数的构造函数就消失。

一个例子

class ClassTest
{
public:
    ClassTest() //定义默认构造函数  第一个
    {
    }
    ClassTest &operator=(const ClassTest &ct) //重载赋值操作符第二个
    {
    }
    ClassTest(const char *pc) //第三个
    {
    }
    ClassTest(const ClassTest &ct) //复制构造函数  第四个
    {
    }
};

ClassTest func(ClassTest temp)
{
    return temp;
}

int main()
{
    cout << "ct1: ";
    ClassTest ct1("ab"); //直接初始化  调用第三个
    cout << "ct2: ";
    ClassTest ct2 = "ab"; //复制初始化   调用第三个
    /*输出说明：
    ClassTest ct2 = "ab";
    它本来是要这样来构造对象的：首先调用构造函数ClassTest(const char *pc)函数创建一个临时对象，
    然后调用复制构造函数，把这个临时对象作为参数，构造对象ct2。然而编译也发现，复制构造函数是公有的，即你明确地告诉了编译器，你允许对象之间的复制，而且此时它发现可以通过直接调用重载的构造函数ClassTest(const char *pc)来直接初始化对象，而达到相同的效果，所以就把这条语句优化为
    ClassTest ct2（"ab"）。
    */
    cout << "ct3: ";
    ClassTest ct3 = ct1; //复制初始化   调用第四个
    cout << "ct4: ";
    ClassTest ct4(ct1); //直接初始化   调用第四个
    cout << "ct5: ";
    ClassTest ct5 = ClassTest(); //复制初始化  调用第一个
    cout << "ct6: ";
    ClassTest ct6;                 //复制初始化  调用第一个
    ct6 = "caoyan is a good boy!"; //调用第三个和第二个
    ClassTest ct7;                 //调用第一个
    ct7 = func(ct6);
    return 0;
}

第一次拷贝构造函数的调用：
第一次很简单，是因为函数参数的传递，将ct6作为参数传递给temp，用ct6的值初始化temp会调用拷贝构造函数；
第二次拷贝构造函数的调用：
因为要返回一个ClassTest对象，我们的编译器怎么做？？？？首先它将temp对象拷贝到func函数的上一级栈帧中，它的上一级栈帧是main函数的栈帧，那么当函数返回时，参数出栈，temp对象的内存空间就会被收回，但是它的值已经被拷贝到main栈帧的一个预留空间中，所以从temp到预留空间的拷贝也是调用拷贝构造函数，最后一步就是给ct7赋值，毫无疑问调用重载等号。