条款07：为多态基类声明为virtual析构函数

本节非常重要，也是几乎所有cpp面试必问的东西。

 

一、多态实现中，base class中的析构函数需要为 virtual 函数

 

 

任何class只要带有virtual函数都几乎可以确定应该有一个virtual析构函数。

如果class不含virtual函数，通常表示它并不意图被用做一个base class。当class不企图当做base class，不能令其析构函数为虚函数。因为实现虚函数，对象需要携带某种信息，主要用来在运行期决定哪一个虚函数该被调用。这份信息通常由虚函数表指出。而C语言没有这东西的，所以不具有移植性，关于虚函数表：

#include <iostream>  
using namespace std;  
   
class Base1 {  
public:  
            virtual void f() { cout << "Base1::f" << endl; }  
            virtual void g() { cout << "Base1::g" << endl; }  
            virtual void h() { cout << "Base1::h" << endl; }  
   
};  
class Base2 {  
public:  
            virtual void f() { cout << "Base2::f" << endl; }  
            virtual void g() { cout << "Base2::g" << endl; }  
            virtual void h() { cout << "Base2::h" << endl; }  
};  
class Base3 {  
public:  
            virtual void f() { cout << "Base3::f" << endl; }  
            virtual void g() { cout << "Base3::g" << endl; }  
            virtual void h() { cout << "Base3::h" << endl; }  
};  
class Derive : public Base1, public Base2, public Base3 {  
public:  
            virtual void f() { cout << "Derive::f" << endl; }  
            virtual void g1() { cout << "Derive::g1" << endl; }  
};  
   
   
typedef void(*Fun)(void);  
   
int main()  
{  
            Fun pFun = NULL;  
   
            Derive d;  
            int** pVtab = (int**)&d;  
   
            //Base1's vtable  
            //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+0);  
            pFun = (Fun)pVtab[0][0];  
            pFun();  
   
            //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+1);  
            pFun = (Fun)pVtab[0][1];  
            pFun();  
   
            //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+2);  
            pFun = (Fun)pVtab[0][2];  
            pFun();  
   
            //Derive's vtable  
            //pFun = (Fun)*((int*)*(int*)((int*)&d+0)+3);  
            pFun = (Fun)pVtab[0][3];  
            pFun();  
   
            //The tail of the vtable  
            pFun = (Fun)pVtab[0][4];  
            cout<<pFun<<endl;  
   
   
            //Base2's vtable  
            //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0);  
            pFun = (Fun)pVtab[1][0];  
            pFun();  
   
            //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);  
            pFun = (Fun)pVtab[1][1];  
            pFun();  
   
            pFun = (Fun)pVtab[1][2];  
            pFun();  
   
            //The tail of the vtable  
            pFun = (Fun)pVtab[1][3];  
            cout<<pFun<<endl;  
   
   
   
            //Base3's vtable  
            //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+0);  
            pFun = (Fun)pVtab[2][0];  
            pFun();  
   
            //pFun = (Fun)*((int*)*(int*)((int*)&d+1)+1);  
            pFun = (Fun)pVtab[2][1];  
            pFun();  
   
            pFun = (Fun)pVtab[2][2];  
            pFun();  
   
            //The tail of the vtable  
            pFun = (Fun)pVtab[2][3];  
            cout<<pFun<<endl;  
            return 0;  
}  

// Derive::f
// Base1::g
// Base1::h
// Derive::g1
// 1
// Derive::f
// Base2::g
// Base2::h
// 1
// Derive::f
// Base3::g
// Base3::h
// 0

 

二、纯虚函数

 

 

 

总结：

1、polymorphic(带多态性质的) base classes 应该声明一个 virtual析构函数。如果class带有任何 virtual函数,它就应该拥有一个 virtual析构函数。
2、Classes的设计目的如果不是作为 base classes使用,或不是为了具备多态性( polymorphically),就不该声明 virtual 析构函数。