虚函数，实现多态性的重要机制

按惯例以实例做分析。

//Instrument1.cpp
#include <iostream>
using namespace std;

enum note{A,B,C};

class Instrument{
public:
    void play(note) const{
        cout<<"Instrument::play"<<endl;
    }
};

//Wind objects are Instruments
//because they have the same interface:
class Wind:public Instrument{
public:
    //Redefine interface function:
    void play(note) const{
        cout<<"Wind::play"<<endl;
    }
};

void tune(Instrument& i){
    //...
    i.play(A);
}

int main(){
    Wind flute;
    tune(flute);//Upcasting
}

以上代码出自 Thinking in C++一书，所以我只是将对书内内容做总结跟字节的理解描述出来，如有不解之处请参考书本。

我们知道，函数tune（）（通过引用）接受一个Instrument，但也不拒绝任何从Instrument派生的类。在main（）中，无需类型转换，就能将Wind对象转给tune（），这符合了向上类型转换（upcasting）：去一个对象的地址（指针或引用），并将其作为基类的地址来处理。那么问题就产生了，我们发现调用输出的是Instrument：：play。这不是期望的输出，因为我们的对象为Wind，自然是希望调用Wind：：play。

解决这个问题需要理解捆绑（binding），关于多态性，我们也常提到了动态捆绑（dynamic binding），其机制是确定运行时对象的类型并调用合适的成员函数。

C++中，可以通过virtual关键字来声明函数为虚函数，动态捆绑只对virtual函数其作用，只在使用含有virtual函数的基类的地址时发生。
仅仅只需在声明时使用关键字virtual，定义时并不需要，而如果一个函数在基类中被声明为virtual，那么在所有的派生类中它都是virtual的。在派生类中virtual函数的重定义通常称为重写（overriding）。尽管在派生类的相应函数声明前加virtual并无害，但显累赘。

修改Instrument2.cpp

//Instrument2.cpp
//Late binding with the virtual keyword
#include <iostream>
using namespace std;

enum note{A,B,C};

class Instrument{
public:
    virtual void play(note) const{ //add virtual
        cout<<"Instrument::play"<<endl;
    }
};

//Wind objects are Instruments
//because they have the same interface:
class Wind:public Instrument{
public:
    //Redefine interface function:
    void play(note) const{
        cout<<"Wind::play"<<endl;
    }
};

void tune(Instrument& i){
    //...
    i.play(A);
}

int main(){
    Wind flute;
    tune(flute);//Upcasting
}

此时，只需在基类Instrument的play函数前加上virtual便实现了动态绑定，此时根据传入的Wind对象而调用Wind：：play。

那么该机制是怎样实现的呢？

每当创建一个包含有虚函数的类或从包含有虚函数的类派生一个类时，编译器就为这个类创建一个惟一的虚表（VTABLE）。在这个表中，编译器放置了在这个类中或在它的基类中所有已声明为virtual的函数的地址。如果在这个派生类中没有对在基类中声明为virtual的函数进行重新定义，编译器就使用基类的这个虚函数地址，而即不为虚也不被重写的函数就以基类的函数地址加入vtable。
下面通过sizeof来说明vptr的存在。

//size.cpp
//Object sizes with/without virtual functions
#include <iostream>
using namespace std;

class NoVirtual{
    int a;
public:
    void x() const{}
    int i() const{return 1;}
};

class OneVirtual{
    int a;
public:
    virtual void x() const{}
    int i() const{return 1;}
};

class TwoVirtual{
    //int a;
public:
    virtual void x() const{}
    virtual int i() const{return 1;}
};

int main()
{
    cout<<"int :"<<sizeof(int)<<endl;
    cout<<"NoVirtual:"<<sizeof(Novirtual)<<endl;
    cout<<"void*:"<<sizeof(void *)<<endl;
    cout<<"OneVirtual:"<<sizeof(OneVirtual)<<endl;
    cout<<"TwoVirtual:"<<sizeof(TwoVirtual)<<endl;
}

[ch1n4@localhost ThinkingInC++]$ ./SizeofVirtualFunc
int :4
NoVirtual:4
void*:4
OneVirtual:8
TwoVirtual:4

由此反映出，如果有一个或多个虚函数，编译器都只在这个结构中掺入一个单个指针（VPTR）。

那么如何定位虚表呢？编译器另外还为每个类的对象提供了一个虚表指针（即vptr），这个指针指向了对象所属类的虚表。
在程序运行时，根据对象的类型去初始化vptr，从而让vptr正确的指向所属类的虚表，从而在调用虚函数时，就能够找到正确的函数。

那么虚表指针在什么时候，或者说在什么地方初始化呢？
答案是在构造函数中进行虚表的创建和虚表指针的初始化：
在构造子类对象时，要先调用父类的构造函数，此时编译器只“看到了”父类，并不知道后面是否后还有继承者，它初始化父类对象的虚表指针，该虚表指针指向父类的虚表。当执行子类的构造函数时，子类对象的虚表指针被初始化，指向自身的虚表。

要注意：对于虚函数调用来说，每一个对象内部都有一个虚表指针，该虚表指针被初始化为本类的虚表。所以在程序中，不管你的对象类型如何转换，但该对象内部的虚表指针是固定的，所以呢，才能实现动态的对象函数调用。

虚函数功能图示：

编译器从这个Instrument指针开始，这个指针指向这个对象的起始地址。对于所有的Instrument对象或由Instrument派生的对象，它们的VPTR都在对象的相同位置（通常在开头）。VPTR指向VTABLE的起始地址。所有的VTABLE都具有相同的顺序，即不论我们在派生类中以什么次序重写都以基类中虚函数的次序为准。
而我们获取到实际函数地址是在运行时，通过VPTR+offset（VPTR指向VTABLE起始地址，即加上偏移来调用相应函数）实现了晚捆绑。
每个函数指针是两个字节长，若函数地址在第二个位置时，即需VPTR+4.