C/C++中的虚析构函数和私有析构函数的使用

代码：

#include <iostream> 

using namespace std;

class A{
    public:
    A(){
        cout<<"construct A"<<endl;
    }
    virtual ~A(){
        cout<<"destory A"<<endl;
    }
};

class B:public A{
    public:
    B(){
        cout<<"construct B"<<endl;
    }
    ~B(){
        cout<<"destory B"<<endl;
    }
};

class C{
    ~C(){
        cout<<"destory C"<<endl;
    }
    public:
        C(){
            cout<<"construct C"<<endl;
        }
        void destory(){
            delete this;
        }
};
int main(){

    A* p = new B;
    delete p;
    C* p1 = new C;//new为在堆上分配空间
    cout<<"new分配地址 "<<p1<<endl;
    //delete p1; //编译出错，不能直接delete
    p1->destory();

    //C t; //编译出错，构造函数为私有的
    
    A a;
    cout<<"不用new "<<&a<<endl;
    

    return 0;
}

输出：

construct A
construct B
destory B
destory A
construct C
new分配地址 0x1623c20
destory C
construct A
不用new 0x7ffcb2ad25b0
destory A

 分析：

1、虚析构函数的作用：当基类指针指向派生类并delete时，可以调用派生类的析构函数；

2、私有析构函数的作用：令对象只能在堆上生成，即用new方法。原理是C++是一个静态绑定语言，在编译过程中，所有的非虚函数调用都必须分析完成（虚函数也要检查可访问性）。因此，当在栈上生成对象时，对象会自动析构，即析构函数必须可以访问。而在堆上生成对象时，析构步骤由程序员控制，不一定需要析构函数。同时，此生成对象不能直接delete删除，析构过程还需要一个专门的成员函数（代码中的destory()函数）。

 

虚析构函数与抽象类结合

代码：

#include <iostream> 
#include <cstdio>

using namespace std; 

class A{
    public:
        //virtual ~A()=0; //如果抽象基类析构函数不需要实现，也可以用纯虚析构函数，但必须在类外加以声明
        virtual ~A(){
            cout<<"destory A"<<endl;
        }
        virtual void func()=0;
};
//A::~A(){}

class B:public A{
    public:
        ~B(){
            cout<<"destory B"<<endl;
        }
        //virtual void func()=0; //如果不实现纯虚函数，则必须重新说明，注意抽象类无法实例化
        void func(){
            cout<<"this is function"<<endl;
        }
};

int main(int argc,char* argv[]){

    A* pA = new B;
    delete pA;

    return 0;
}

输出：

destory B
destory A