c++之——虚析构函数

先看代码：

 #include<iostream>
 using namespace std;

 class Parent {
 public:
     Parent() :a(), b(), c()
     {

         p = new char[];
         //strcpy(p, "abc");
         cout << "parent 无参构造。。。\n";
     }
     Parent(int test) :a(), b(), c()
     {
         p = new char[];
         //strcpy(p, "abc");
         cout << "parent 有参构造。。。\n";
     }
     ~Parent()
     {
         delete[] p;
         cout << "Parent 析构。。。\n";
     }
     int a;
     int b;
     int c;
     char *p;
     void p_print()
     {
         cout << "a b c is" << a << " " << b << " " << c << endl;
     }

 };
 class Child1 :  public Parent
 {
 public:
     Child1() :Parent(),a(), b(), c()
     {
         p = new char[];
     //    strcpy(p, "abc");
         cout << "child1 构造\n";
     }
     ~Child1()
     {
         delete[] p;
         cout << "child1 析构，，，\n";
     }
     void c1_print()
     {
         cout << "a b c is" << a << " " << b << " " << c << endl;
     }

     int a;
     int b;
     int c;
     char *p;
 };
 class Child2 :  public Child1
 {
 public:
     Child2() :Child1(), b(), c()
     {
         p = new char[];
         //strcpy(p, "abc");
         cout << "child2 构造\n";
     }
     ~Child2()
     {
         delete[] p;
         cout << "child2 析构，，，\n";
     }
     void c2_print()
     {
         cout << "a b c is" << Parent::a << " " << b << " " << c << endl;
     }
     //int a;
     int b;
     int c;
     char *p;
 };
 /*
 class Child3 : public Child1, public Child2
 {
 public:
     Child3() : Child1(), Child2(), b(20), c(30) { cout << "child 构造\n"; }
     ~Child3()
     {
         cout << "child 析构，，，\n";
     }
     void c3_print()
     {
         cout << "a b c is" << a << " " << b << " " << c << endl;
     }
     //int a;
     int b;
     int c;
 };
 */
 void play()
 {
     Child2* c2 = new Child2;
     delete c2;
 }
 int main()
 {
     //Child2* c2 = new Child2;
     play();
     return ;
 }

这样是没问题的（c++编译器会以构造相反的顺序执行析构函数），但是，在很多时候，我们不能在调用函数末尾就delete掉这个内存，还需要和后续交互。比如作为函数参数，为了实现多态，我们函数参数是父类的指针，所以更常见和一般的设计思维是更改paly和main函数如下：

 void play(Parent* p)
 {
     delete p;
 }
 int main()
 {
     Child2* c2 = new Child2;
     play(c2);
     return ;
 }

运行结果显示内存泄漏了，只析构了父类；所以我们有那么一种需求，要想和多态的效果一样，传什么指针去，自动析构应该析构的东西，更改代码，实现虚析构函数。

只用更改基类的析构函数，加上virtual关键字：

     virtual ~Parent()
     {
         delete[] p;
         cout << "Parent 析构。。。\n";
     }

这样就没有内存泄漏了。

知识简要：

如果基类的析构函数不是虚函数，则delete一个指向派生类对象的基类指针将产生未定义的行为。之前我们介绍过一个准则，如果一个类需要析构函数，那么它同样需要拷贝和赋值操作。基类的析构函数并不遵循上述准则，它是一个重要的例外。