对象和类——对象的构造顺序

本文参照于狄泰软件学院，唐佐林老师的——《C++深度剖析教程》

在程序中，各种作用域的对象很多，有些对象还包含在别的对象中，还有些对象早在main()函数开始之前就已经建立了。创建对象的唯一途径就是调用构造函数。构造函数是一段程序代码，所以构造对象的先后顺序不同，直接影响程序执行的先后顺序，导致不同的运行结果。

---

问题：Ｃ＋＋中的类可以定义多个对象，那么对象构造的顺序是怎么样？

局部对象的构造顺序

当程序执行到达对象的定义语句时进行构造。

示例代码：局部变量的构造顺序

#include <stdio.h>

class Test
{
private:
    int mi;
public:
    Test(int i)
    {
        mi = i;
        printf("Test(int i): %d\n", mi);
    }
    Test(const Test& obj)
    {
        mi = obj.mi;
        printf("Test(const Test& obj): %d\n", mi);
    }
};


void func(void)
{
    printf("func:");
    Test a4 = 4;
    static Test a5 = 5;
}

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

    while( i < 3 )
    {
        Test a2 = ++i;  //1,2,3
    }

    if( i < 4 )
    {
        Test a = a1;   //0
    }
    else
    {
        Test a(100);
    }

    func();
    func();

    return 0;
}

输出结果：
Test(int i): 0
Test(int i): 1
Test(int i): 2
Test(int i): 3
Test(const Test& obj): 0
func:Test(int i): 4
Test(int i): 5
func:Test(int i): 4

分析：
1. 对象的构造顺序是根据运行中定义对象的顺序来决定对象创建的顺序的。
2. 静态局部变量被多次调用只创建一次。这是因为静态局部变量和全局变量一样，都是存放在全局数据区。而不是栈上。作用域是文件，生命周期是整个程序运行期，所以不需要多次创建。

堆对象的构造顺序

1. 当程序执行流到达new语句时创建对象
2. 使用new创建对象将自动触发构造函数的调用。

示例代码：堆对象的构造顺序

#include <stdio.h>

class Test
{
private:
    int mi;
public:
    Test(int i)
    {
        mi = i;
        printf("Test(int i): %d\n", mi);
    }
    Test(const Test& obj)
    {
        mi = obj.mi;
        printf("Test(const Test& obj): %d\n", mi);
    }
    int getMi()
    {
        return 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;
}

输出结果：
Test(int i): 0
Test(int i): 1
Test(int i): 3
Test(int i): 5
Test(int i): 7
Test(int i): 9
Test(int i): 100

分析：
堆对象的构造顺序与局部变量的构造顺序相同。都是通过程序执行流来确定的。

全局变量的构造顺序

1. 对象的构造顺序是不确定的；
2. 不同的编译器使用不同的规则确定构造顺序。

示例代码：全局变量的构造顺序

//test.h
#ifndef _TEST_H_
#define _TEST_H_

#include <stdio.h>

class Test
{
public:
    Test(const char* s)
    {
        printf("%s\n", s);
    }
};

#endif

//t1.cpp
#include "test.h"

Test t1("t1");

//t2.cpp
#include "test.h"

Test t2("t2");

//t3.cpp
#include "test.h"

Test t3("t3");

Main.cpp
#include "test.h"

Test t4("t4");

int main()
{
    Test t5("t5");
}

在Linux g++编译器执行结果：
g++ main.cpp t3.cpp t1.cpp t2.cpp test.h
t2
t1
t3
t4
t5

VS2010编译器执行结果：
t2
t3
t1
t4
t5

分析：
全局对象的构造顺序是亦不一定的，编译器不同，构造顺序就不同。

原因分析：
1. 和全局变量一样，所有全局对象在主函数启动之前，全部被构造
2. 因为程序时从MAIN开始执行的，则说明程序顺序执行在MAIN之后才是可控的。但全局对象并不依赖于MAIN函数之后的运行顺序，它早在MAIN运行之前就创建完毕了。而全局对象的创建顺序在标准的C++中没有规定，一切根据编译器的内在特性而定。因而不同的编译器做法不同。
3. 在C中，我们建议尽量不要使用全局变量，而C++中我们则建议尽量不要使用全局对象。更不要让全局对象相互依赖。