析构函数什么时候被调用

析构函数什么时候被调用
析构函数在下边3种状况时被调用：

对象生命周期结束，被销毁时；
主动调用delete ；
对象i是对象o的成员，o的析构函数被调用时，对象i的析构函数也被调用。
第一种状况

#include <iostream>

using namespace std;

class A
{
public:
    A()
    {
        cout << "constructing A" << endl;
    }
    ~A()
    {
        cout << "destructing A" << endl;
    }
private:
    int a;
};

void main()
{
    A a;
}

运行结果：

constructing A
destructing A
1
2
第二种状况

若是是new的对象，即便离开了做用域也会一直存在，必须主动delete，不然只有在结束程序时才会执行析构。这里在说下内存泄漏，举个例子

#include <iostream>

using namespace std;

class A
{
public:
    A()
    {
        cout << "constructing A" << endl;
    }
    ~A()
    {
        cout << "destructing A" << endl;
    }
private:
    int a;
};

void fun() 
{
    A *a = new A();
}

int main() 
{
    while (1) 
    {
        fun();
    }
    return 0;
}

当离开fun时，虽然离开了做用域，但用new动态开辟空间的对象是不会析构的，你能够观察任务管理器，看到内存一直在上升。但你在其余地方确没法使用a所开辟的空间，由于a这个指针是保存在栈上的，当离开做用域后就自动析构(或者说自动消失了)，但它所在分配空间是分配在堆上的，只有主动析构或程序结束，才会释放空间，也就是丢失了这块空间的地址，没法操做这块空间了 。

第三种状况

#include <iostream>

using namespace std;

class A
{
public:
    A()
    {
        cout << "constructing A" << endl;
    }
    ~A()
    {
        cout << "destructing A" << endl;
    }
private:
    int a;
};

class C
{
public:
    C()
    {
        cout << "constructing C" << endl;
    }
    ~C()
    {
        cout << "destructing C" << endl;
    }
private:
    int c;
};

class B : public A
{
public:
    B()
    {
        cout << "constructing B" << endl;
    }
    ~B()
    {
        cout << "destructing B" << endl;
    }
private:
    int b;
    C c;
};

void main()
{
    B b;
}

运行结果：

constructing A
constructing C
constructing B
destructing B
destructing C
destructing A

B的析构函数调用以后，又调用了B的成员c的析构函数 。

若将上边的代码中的main()函数内容改为

 A* a = new B;

 delete a;

咱们知道，这将不会调用class B的析构函数不会被调用，因此class C的析构函数也不会被调用。

运行结果：

constructing A
constructing C
constructing B
destructing A

若将class A中的析构函数声明为虚函数 ，这时class B的析构函数也会被调用，例如：

#include <iostream>

using namespace std;

class A
{
public:
    A()
    {
        cout << "constructing A" << endl;
    }
    virtual ~A()
    {
        cout << "destructing A" << endl;
    }
private:
    int a;
};

class C
{
public:
    C()
    {
        cout << "constructing C" << endl;
    }
    ~C()
    {
        cout << "destructing C" << endl;
    }
private:
    int c;
};

class B : public A
{
public:
    B()
    {
        cout << "constructing B" << endl;
    }
    ~B()
    {
        cout << "destructing B" << endl;
    }
private:
    int b;
    C c;
};

void main()
{
    A* a = new B;

    delete a;
}

运行结果：

constructing A constructing C constructing B destructing B destructing C destructing A