c++之——虚析构函数

先看代码：

#include<iostream>
using namespace std;

class Parent {
public:
    Parent() :a(100), b(200), c(300)
    {
        
        p = new char[10];
        //strcpy(p, "abc");
        cout << "parent 无参构造。。。
";
    }
    Parent(int test) :a(1000), b(2000), c(3000)
    {
        p = new char[10];
        //strcpy(p, "abc");
        cout << "parent 有参构造。。。
";
    }
    ~Parent()
    {
        delete[] p;
        cout << "Parent 析构。。。
";
    }
    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(1),a(10), b(0), c(0) 
    { 
        p = new char[10];
    //    strcpy(p, "abc");
        cout << "child1 构造
";
    }
    ~Child1()
    {
        delete[] p;
        cout << "child1 析构，，，
";
    }
    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(2), c(3) 
    { 
        p = new char[10];
        //strcpy(p, "abc");
        cout << "child2 构造
"; 
    }
    ~Child2()
    {
        delete[] p;
        cout << "child2 析构，，，
";
    }
    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 构造
"; }
    ~Child3()
    {
        cout << "child 析构，，，
";
    }
    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 0;
}

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

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

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

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

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

这样就没有内存泄漏了。

知识简要：

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