一般情况下，调用析构函数的次序正好与调用构造函数的次序相反，也就是最先被调用的构造函数，其对应的析构函数最后被调用，而最后被调用的构造函数，其对应的析构函数最先被调用。

        当然对象的构造函数和析构函数调用时机和它的生命周期是密不可分的。 下面归纳一下什么时候调用构造函数和析构函数。
        （1）全局对象(生命周期:程序运行时创建,程序结束时销毁)的构造函数在所有函数（包括main函数）执行之前调用。但如果一个程序中有多个文件，而不同的文件中都定义了全局对象，则这些对象的构造函数的执行顺序是不确定的。当main函数执行完毕或调用exit函数时（此时程序终止），调用其析构函数。
        （2）局部对象（在函数内定义的对象,其生命周期是进入该函数创建,函数退出结束）在进入该函数建立对象时调用其构造函数。如果函数被多次调用，则在每次建立对象时都要调用构造函数。在函数调用结束时调用析构函数。
        （3）如果在函数中定义了静态（static）局部对象(生命周期是第一次进入该函数创建,程序退出时销毁)，则只在程序第一次调用此函数建立对象时调用一次构造函数，在调用结束时对象并不被释放，因此也不调用析构函数，只在main函数结束或调用exit函数结束程序时，才调用析构函数。
        （4）动态创建的对象,是调用new关键字创建函数时调用构造函数,调用delete函数销毁对象时调用析构函数。

1.全局变量

例如:构造函数与析构函数执行顺序。

//1.全局对象
class Time  //时间类
{
private:
    int hour;
    int minute;
    int second;
public:
    Time(int h, int m, int s); //构造函数
    ~Time();//析构函数
};
Time::Time(int h, int m, int s) //定义构造函数
{
    hour = h;
    minute = m;
    second = s;
    cout << "时间 构造函数:" << hour << ":" << minute << ":" << second << endl;
}
Time::~Time()//定义析构函数
{
    cout << "时间 析构函数: " << hour << ":" << minute << ":" << second << endl;
}

Time g_a = {8,0,0};
Time g_b = {9,0,0};
static Time g_c = {10,10,10};
static Time g_d = {11,11,11};

int main()
{
    cout << "进入main()" << endl;

    cout << "退出main()" << endl;
    return 0;
}

2.局部变量

对局部对象和局部静态对象的测试如下:

//2.局部对象和局部静态对象
class Time  //时间类
{
private:
    int hour;
    int minute;
    int second;
public:
    Time(int h, int m, int s); //构造函数
    ~Time();//析构函数
};
Time::Time(int h, int m, int s) //定义构造函数
{
    hour = h;
    minute = m;
    second = s;
    cout << "时间 构造函数:" << hour << ":" << minute << ":" << second << endl;
}
Time::~Time()//定义析构函数
{
    cout << "时间 析构函数: " << hour << ":" << minute << ":" << second << endl;
}

void Fun()
{
    cout << "进入Fun()" << endl;
    Time a = { 12,0,0 };
    Time b = { 13,0,0 };
    static Time c = { 14,14,14 };
    static Time d = { 15,15,15 };
    cout << "退出Fun()" << endl;
}

int main()
{
    cout << "进入main()" << endl;
    Fun();
    cout << "退出main()" << endl;

    return 0;
}

执行结果如下:

3.动态内存

动态创建对象测试如下:

//动态对象
class Time  //时间类
{
private:
    int hour;
    int minute;
    int second;
public:
    Time(int h, int m, int s); //构造函数
    ~Time();//析构函数
};
Time::Time(int h, int m, int s) //定义构造函数
{
    hour = h;
    minute = m;
    second = s;
    cout << "时间 构造函数:" << hour << ":" << minute << ":" << second << endl;
}
Time::~Time()//定义析构函数
{
    cout << "时间 析构函数: " << hour << ":" << minute << ":" << second << endl;
}

int main()
{
    cout << "进入main()" << endl;
    Time* pt1 = new Time{16,0,0};
    Time* pt2 = new Time{17,0,0};//没有delete,内存泄漏
    delete pt1;

    cout << "退出main()" << endl;
    return 0;
}

程序执行结果如下:

4.其它情况

全局变量和局部变量夹杂情况如下,程序运行结果是什么呢?

class Time  //时间类
{
private:
    int hour;
    int minute;
    int second;
public:
    Time(int h, int m, int s); //构造函数
    ~Time();//析构函数
};
Time::Time(int h, int m, int s) //定义构造函数
{
    hour = h;
    minute = m;
    second = s;
    cout << "时间 构造函数:" << hour << ":" << minute << ":" << second << endl;
}
Time::~Time()//定义析构函数
{
    cout << "时间 析构函数: " << hour << ":" << minute << ":" << second << endl;
}
class Date  //日期类
{
private:
    int year;
    int month;
    int day;
public:
    Date(int y, int m, int d); //声明构造函数
    ~Date(); //声明析构函数
}yesteday(2023, 4, 21); //定义全局对象

Date::Date(int y, int m, int d) //定义构造函数
{
    year = y;
    month = m;
    day = d;
    //在类Date定义的构造函数中定义类Time的对象（局部）
    Time time{ 11, 11, d };
    cout << "日期 构造函数: " << year << ":" << month << ":" << day << endl;
}
Date::~Date()
{
    cout << "日期 析构函数: " << year << ":" << month << ":" << day << endl;
}

int main()
{
    cout << "进入 main()" << endl;
    Date today(2023, 4, 22);
    cout << "退出 main()" << endl;

    return 0;
}