为什么析构函数也要虚呢。。。。

C/C++ code
class TestBase
{
public:
    virtual ~TestBase(){}
    virtual void out(){
        cout<<"Base"<<endl;
    }
};

class TestDerive
{
public:
    virtual ~TestDerive(){}

    void  out(){
        cout<<"Derive"<<endl;
    }
};

int main()
{
        TestDerive *pDerive = new TestDerive();
    TestBase *pBase = (TestBase *) pDerive;
    pDerive->out(); //输出“Derive”
    pBase->out();  //输出“Derive”也是虚的。
    delete pBase;

    system("pause");
}

妈的不在状态！！

C/C++ code
class TestBase
{
public:
    virtual ~TestBase(){}
    virtual void out(){
        cout<<"Base"<<endl;
    }
};

class TestDerive : public TestBase
{
public:
    virtual ~TestDerive(){}

    void  out(){
        cout<<"Derive"<<endl;
    }
};

int main()
{
        TestDerive *pDerive = new TestDerive();
    TestBase *pBase = (TestBase *) pDerive;
    pDerive->out(); //输出“Derive”
    pBase->out();  //输出“Derive”也是虚的。
    delete pBase;

    system("pause");
}

意思不是这个,我的意思是定义的时候如果不是虚函数形式,而是基类和派生类函数同名,这个时候用派生类地址赋给基类指针的话,用这个指针来调用函数是调用的哪个的?

派生的虚虚构函数在调用的时候同时也调用了基类的析够函数,这样用起来方便

但是基类和派生类的析构函数即使不是虚的，那么在派生类对象被析构的时候也会自动调用基类的析构函数啊

那么方便在哪里呢

没用Virtual怎么是虚函数，那个是被基类覆盖派生类了吧！

这个叫做同名覆盖。

楼主把下面的这个例子看懂就清楚了。


C/C++ code
#include<iostream>
using namespace std;
class Base
{
public:
    virtual void xfn(int i)
    {
        cout << "Base::xfn(int i)" << endl;
    }

    void yfn(float f)
    {
        cout << "Base::yfn(float f)" << endl;
    }

    void zfn()
    {
        cout << "Base::zfn()" << endl;
    }
};

class Derived:public Base
{
public:
    void xfn(int i)
    {
        cout << "Derived::xfn(int i)" << endl;
    }

    void yfn(int c)
    {
        cout << "Derived::yfn(int c)" << endl;
    }

    void zfn()
    {
        cout << "Derived::zfn()" << endl;
    }
};


void main()
{
    Derived d;
    Base *pB    = &d;
    pB->xfn(5);
    pB->yfn(3.14f);
    pB->zfn();

    cout << "========================" << endl;

    Derived *pD = &d;
    pD->xfn(5);
    pD->yfn(3.14f);   
    pD->zfn();
}

为什么析构函数也要虚呢。。。。
使用基类的指针指向派生对象时，如果析构函数不是虚函数那么就不会调用到派生类的析构函数