21，对象的构造顺序

好多bug由对象构造造成--------对象的构造与构造函数有关系

1. 对象的构造顺序

—C++中的类可以定义多个对象，那么对象构造顺序是怎样的？

（1）对于局部对象：当程序执行流到达对象的定义语句时进行构造。   对象定义--->构造---->调用构造函数

#include<stdio.h>

class Test
{
private:
    int mi;
public:
    Test(int i)   //构造函数
    {
        mi = i;
        printf("Test(int i) : %d
",mi);
    }
    Test(const Test& obj)    //拷贝构造函数
    {
        mi = obj.mi;
        printf("Test(const Test& obj) : %d
", mi);
    }

    /*
    int getMi()
    {
        return mi;
    }
    */
};

int main()
{
    int i = 0;
    Test a1 = i;        // 对象构造    Test(int i) ：0

    while (i < 3)
    {
        Test a2 = ++i;   //对象的定义，那么就有对象构造3次      Test(int i) ：1，2，3
    }

    if (i < 4)
    {
        Test a = a1;   //对象的定义，那么就有对象拷贝构造      Test(const Test& obj) : 0
    }
    else
    {
        Test a(100);
    }

    /*
goto End;  不能非法改变程序的执行流

            Test a(100);               //a没有构造，初始化，后面不能使用
End:
            printf("a.mi=%d
",a.getMi());   //没有初始化对象，没有调用构造函数，有的编译器会输出随机值

    */
    return 0;
}

（2）对于堆对象

　　①当程序执行流到达new语句时创建对象

　　②使用new创建对象将自动触发构造函数的调用

#include<stdio.h>

//堆对象的构造顺序    Test* a1 = new Test(i);  

class Test
{
private:
    int mi;
public:
    Test(int i)    //构造函数
    {
        mi = i;
        printf("Test(int i) : %d
", mi);
    }
    Test(const Test& obj)    //拷贝构造函数
    {
        mi = obj.mi;
        printf("Test(const Test& obj) : %d
", mi);
    }

};

int main()
{
    int i = 0;
    Test* a1 = new Test(i);                 //Test(int i) : 0

    while (++i < 10)
        if (i % 2)
            new Test(i);                    //Test(int i) : 1,3,5,7,9

    if (i < 4)
        new Test(*a1);                    

    else
        new Test(100);                      //Test(int i) :100

    return 0;
}

（3）对于全局对象

　　①对象的构造顺序是不确定的

　　②不同的编译器使用不同的规则确定构造顺序

//test.h

#ifndef _TEST_H_
#define _TEST_H_
#include<stdio.h>
 
class Test
{
public:
    Test(const char* s)
    {
        printf("%s
", s);
    }
}; 
#endif

//t1.cpp

Test t1("t1");//全局变量

//t2.cpp

#include "test.h"

Test t2("t2");//全局变量

//t3.cpp

#include "test.h"
 
Test t3("t3");//全局变量

//main.cpp

#include <stdio.h>
#include "test.h"

//注意：全局变量会先于main函数执行，因此

//4个全局变量t1-t4会被先构造，再其顺序是不确定的，

//要依赖于编译器。 那么不同的编译器使用不同的规则确定全局变量的构造顺序

//当构造完全局对象后，会执行main函数，可以发现

//t5是最后一个被构造的。

Test t4("t4"); //全局变量  他的构造在main()之前
 
int main()
{
    Test t5("t5"); //局部对象，他的构造按照程序执行流
    return 0;
}

g++编译器的输出结果:

//实验1：g++ main.cpp t1.cpp t2.cpp t3.cpp

//t3->t2->t1->t4->t5:  从右向左

//实验2：g++  t3.cpp t1.cpp main.cpp t2.cpp

//t2->t4->t1->t3->t5:  从右向左

2.小结

（1）局部对象的构造顺序依赖于程序的执行流

（2）堆对象的构造顺序依赖于new的使用顺序

（3）全局对象的构造顺序是不确定的