c++ primer plus阅读笔记13---虚函数 为什么要虚析构函数？

虚函数
虚函数主要是用来实现动态多态的，我们来看下边的代码：

class Base
{
    ...
    public:
        void function()
        {
            ...
        }
};
class Extends:public Base
{
    ...
    public:
        void function()
        {
            ...
        }
};
int main()
{
    Base base;
    Extends extends;
    Base &b1=base;
    Base &b2=extends;  //父类的引用指向子类，向上转型
    b1.fuctione(); //相当于:Base::function();
    b2.function(); //相当于:Base::function();
}

如果没有使用关键字virtual，程序将根据引用类型或指针类型来选择方法，main函数中，b1,b2的引用类型都是Base，所以调用的是父类的function方法;
如果在父类的function的定义前边加上关键字virtual，则调用b2.function()相当于:Extends::function();

class Base
{
public:
//加了关键字virtual以后，这个函数成了虚函数，此时子类的function也成了虚函数，但是子类的virtual可以省略，
    virtual void function() 
    {
        std::cout<<"调用了父类的function方法"<<std::endl;
    }
};

class Extends:public Base
{
public:
    void function()
    {
        std::cout<<"调用了子类的function方法"<<std::endl;
    }
};

int main()
{
    Base base;
    Extends extends;
    Base &b1=base;
    Base &b2=extends;
    b1.function();
    b2.function();　//相当于：Extends::function();
}

为何要使用虚函数？
加了关键字virtual以后，将会根据对象的实际类型来选择调用的函数。
我们在堆上申请一块内存存放子类的对象，并且使用父类的指针指向它，当我们是放这块内存的时候，需要调用这块内存对象的析构函数，但是我们使用的是父类的指针指向了它，如果析构函数没有不是虚析构函数，则会调用父类的析构函数，不会调用子类的析构函数。如果在子类的构造函数申请一块内存，并且在析构函数中释放这块内存，如果子类的析构函数没有被调用，将会造成内存泄露。因此需要在父类的析构函数上加上关键字virtual，这样调用析构函数的时候，会调用实际对象的类型的析构函数，如下代码：

class Base
{
public:
    virtual void function()
    {
        std::cout<<"调用了父类的function方法"<<std::endl;
    }
     ~Base()
    {
        std::cout<<"调用了父类的析构函数"<<std::endl;
    }
};

class Extends:public Base
{
public:
    Extends()
    {
        std::cout<<"调用了子类的构造函数"<<std::endl;
        p=new int(20);　//如果父类的析构函数不是虚析构函数，则以main函数中的方式释放内存，只调用了父类的析构函数，这块内存无法释放，造成内存泄露。
        for(int i=0;i<20;i++)
        {
            *(p+i)=i;
        }
    }

    void function()
    {
        std::cout<<"调用了子类的function方法"<<std::endl;
    }
    void test()
    {
        std::cout<<"调用了子类的特有函数"<<std::endl;
    }

    void show()
    {
        for(int i=0;i<20;i++)
        {
            std::cout<<*(p+i)<<std::endl;
        }
    }
    ~Extends()
    {
        std::cout<<"调用了子类的析构函数"<<std::endl;
    }

private:
    int *p;
};

int main()
{
    Base *base=new Extends();
    base->function();
    delete base;　//销毁base指向的对象，调用其析构函数，这里只会调用父类的析构函数，造成子类中的p指针指向的内存泄露。

}

上边这个例子阐述了虚析构函数的重要性。