多态和虚表

一，多态
在面向对象的方法中一般是这样描述多态的：向不同的对象发送同一个消息，不同的对象在接收时会产生不同的行为（即方法）。多态性的表现形式之一是：具有不同功能的函数可以用同一个函数名，这样就可以实现用一个函数名调用不同内容的函数。

1，静态多态

静态多态是通过函数重载实现的。由函数重载和运算符重载形成的多态性属于静态多态，要求编译器在程序编译时就知道调用函数的全部信息。静态多态性又称编译时的多态性。静态多态性的函数调用速度快，效率高，但缺乏灵活性，在程序运行前就已经决定了执行的函数和方法。

2，动态多态性

C++中是用虚函数实现动态多态性的。
虚函数的作用是允许在派生类中重新定义与基类同名的函数，并且可以通过基类指针或引用来访问基类和派生类中的同名函数。通过下面的代码举例说明：

class Student
{
public:
    Student(int n, string nam, float s)
        :num(n), name(nam), score(s){}
    void display()
    {
        cout << "num:" << num << "\nname:" << name<< "\nscore:" << score << "\n\n";
    }
protected:
    int num;
    string name;
    float score;
};

class Graduate :public Student
{
public:
    Graduate(int n, string nam, float s, float w)
        :Student(n, nam, s), wage(w){}
    void display()
    {
        cout << "num:" << num << "\nname:" << name << "\nscore:" << score << "\nwage:" << wage << "\n\n";
    }
private:
    float wage;
};

int main()
{
    Student stud(1001, "Li", 87.5);
    Graduate grad(2001, "wang", 98.5, 1200);//并没有调用派生类的函数
    Student *pt = &stud;
    pt->display();
    pt = &grad;
    pt->display();
    system("pause\n");;
    return 0;
}

程序运行结果如下：

可以看到，主函数并没有打印派生类中新增加的成员变量，和我们预想的结果不同，那么如何打印出派生类中的wage？在基类的dispaly函数前加上virtual,.我们再来看程序的运行结果：

可以看到：当把基类的某个成员函数声明为虚函数后，允许在其派生类中对该函数重新定义，赋予它新的功能，并且可以通过指向基类的指针指向同一类族中的不同类的对象，从而调用其中的同名函数。
注意：由虚函数实现的动态多态性就是：同一类族中不同类的对象，对同一函数做出不同的响应。动态多态性的特点是：不在编译时确定是哪个函数，而是在程序运行过程中动态的确定操作所针对的对象，它又称运行时多态性。

虚函数的使用方法是：
（1）在基类中用virtual声明成员函数为虚函数。在类外定义虚函数时，不必再加virtual.
（2）在派生类中重新定义此函数，函数名、函数类型、函数参数、函数参数个数和类型必须与基类的虚函数相同，根据派生类的需要重新定义函数体。
（3）定义一个指向基类对象的指针变量，并使它指向同一类族中需要调用该函数的对象。
（4）通过该指针变量调用此虚函数，此时调用的就是指针变量指向的对象的同名函数。

使用虚函数，系统会有一定的空间开销。当一个类带有虚函数时，编译系统会为该类构造一个虚函数表（虚表），后面我们将会介绍。系统在进行动态关联时时间开销是很少的，因此多态性是高效的。

3，虚析构函数
先来看一段代码

class Point
{
public:
    Point(){}
    ~Point()
    {
        cout << "exeuting Point destructor" << endl;
    }
};
class Circle :public Point
{
public:
    Circle(){}
    ~Circle()
    {
        cout << "executing Circle destructor" << endl;
    }
private:
    int radus;
};

int main()
{
    Point *p = new Circle;
    delete p;
    return 0;
}

执行之后可以看到如下结果：

程序并没有执行派生类的析构函数。如果希望呢个执行派生类的析构函数，可以将基类的析构函数声明为虚函数。

一般都会显式地将基类的析构函数定义为虚函数，以保证在撤销动态分配的空间时能得到正确的处理。
构造函数不能被定义为虚函数。这是因为在执行构造函数时类对象还未完成建立过程，当然谈不上把函数与类对象绑定。
静态成员函数不能是虚函数。因为静态成员函数的特点是不受限制于某个对象。
内联函数不能是虚函数。因为内联函数不能在运行中动态确定位置。

5，纯虚函数
有时在基类中将某一函数定义为虚函数，并不是基类的需要，而是考虑到派生类的需要，在基类中预留了一个函数名，具体功能留给派生类根据需要去定义。
例如，我们在写计算各种几何图形的面积、体积等的程序时，“点”并没有面积，也没有体积，但考虑到圆、圆柱等图形的需要，通常我们会在基类中将这些函数声明为纯虚函数，即以下形式：

virtual float area() const = 0;//纯虚函数 

纯虚函数是在声明虚函数时被“初始化”为0的函数。
注意：（1）纯虚函数没有函数体；（2）最后面的“=0”不表示函数返回值为0，它只起形式上的作用，告诉编译器这是纯虚函数；（3）这是声明语句，后面应有分号。
纯虚函数只有函数的名字而不具备函数的功能，不能被调用。

二，虚表
前面提到的虚表，它是一个指针数组，存放每个虚函数的入口。
我们先来看一个现象：

注意其中析构函数没有virtual,下面我们给它加上virtual,再来看打印结果

结果怎么变成了8？下面对程序进行调试：

对于有虚函数的类，编译器都会维持一张虚表，对象的前四个字节就是指向虚表的指针。

class CBase
{
public:
    virtual void FunTest0(){ cout << "CBase::FunTest0()" << endl; }
    virtual void FunTest1(){ cout << "CBase::FunTest1()" << endl; }
    virtual void FunTest2(){ cout << "CBase::FunTest2()" << endl; }
    virtual void FunTest3(){ cout << "CBase::FunTest3()" << endl; }
};
class CDerived :public CBase
{
public:
    virtual void FunTest0(){ cout << "CDerived::FunTest0()" << endl; }
    virtual void FunTest1(){ cout << "CDerived::FunTest1()" << endl; }
    virtual void FunTest4(){ cout << "CDerived::FunTest4()" << endl; }
    virtual void FunTest5(){ cout << "CDerived::FunTest5()" << endl; }
};
typedef void(*_pFunTest)();
void FunTest()
{
    CBase base;
    for (int iIdx = 0; iIdx < 4; ++iIdx)
    {
        _pFunTest pFunTest = (_pFunTest)(*((int*)*(int *)&base + iIdx));
        pFunTest();
    }
    cout << endl<< endl;
    CDerived derived;
    for (int iIdx = 0; iIdx < 6; ++iIdx)
    {
        _pFunTest pFunTest = (_pFunTest)(*((int*)*(int *)&derived + iIdx));
        pFunTest();
    }
}
void TestVirtual()
{
    CBase base0;
    CDerived derived;
    CBase& base1 = derived;
}
int main()
{
    FunTest();
    TestVirtual();
    system("pause\n");
    return 0;
}

打印结果如下：

派生类的虚函数表的生成：
（1）先拷贝基类的虚函数表
（2）如果派生类重写了基类的某个虚函数，就替换同位置的基类虚函数
（3）最后是派生类自己的虚函数

通过基类的引用或指针调用虚函数时，调用基类还是派生类的虚函数，要根据运行时引用实际引用的类型确定。调用非虚函数时，则无论基类指向的是何种类型，都调用的是基类的函数。

多重继承时的虚表
1，无虚函数覆盖时的情况
假设有如下继承方式：

对于子类实例中的虚表，如下：

（1）每个父类都有自己的虚表
（2）子类的成员被放到了第一个父类的虚表中（按照声明顺序）
2，有虚函数覆盖时
下面在子类中覆盖了基类的f()函数：

下面是子类虚表图：

可以看到，三个父类虚表中的f(）的位置被替换承认那个老人子类的函数指针。这样，我们就可以让任一静态类型的父类来指向子类。
如：

Derive d;
Base *b1 = &d;
b1->f();