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 ;
 }

输出：

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()=;
 };
 //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 ;
 }

输出：

destory B
destory A