多態(Polymorphism)是面向對象的核心概念，本文以C++為例，討論多態的具體實現。C++中多態可以分為基于繼承和虛函數的動態多態以及基于模板的靜態多態，如果沒有特別指明，本文中出現的多態都是指前者，也就是基于繼承和虛函數的動態多態。至于什么是多態，在面向對象中如何使用多態，使用多態的好處等等問題，如果大家感興趣的話，可以找本面向對象的書來看看。
為了方便說明，下面舉一個簡單的使用多態的例子(From [1] )：
class
Shape
{
protected:
int m_x; // X coordinate
int m_y; // Y
coordinate
public:
// Pure virtual function for drawing
virtual
void Draw() = 0;
// A regular virtual function
virtual void
MoveTo(int newX, int newY);
// Regular method, not overridable.
void Erase();
// Constructor for Shape
Shape(int x, int
y);
// Virtual destructor for Shape
virtual ~Shape();
};
//
Circle class declaration
class Circle : public Shape
{
private:
int m_radius; // Radius of the circle
public:
// Override to draw a
circle
virtual void Draw();
// Constructor for Circle
Circle(int x, int y, int radius);
// Destructor for Circle
virtual ~Circle();
};
//
Shape constructor implementation
Shape::Shape(int x, int y)
{
m_x =
x;
m_y = y;
}
// Shape destructor
implementation
Shape::~Shape()
{
//...
}
//
Circle constructor implementation
Circle::Circle(int x, int y, int radius) :
Shape (x, y)
{
m_radius = radius;
}
// Circle destructor
implementation
Circle::~Circle()
{
//...
}
// Circle override
of the pure virtual Draw method.
void Circle::Draw()
{
glib_draw_circle(m_x, m_y, m_radius);
}
main()
{
// Define a circle with a center at (50,100) and a radius of 25
Shape
*pShape = new Circle(50, 100, 25);
// Define a circle with a center at
(5,5) and a radius of 2
Circle aCircle(5,5, 2);
// Various
operations on a Circle via a Shape pointer
//Polymorphism
pShape->Draw();
pShape->MoveTo(100, 100);
pShape->Erase();
delete
pShape;
// Invoking the Draw method directly
aCircle.Draw();
}
例子中使用到多態的代碼以黑體標出了，它們一個很明顯的特征就是通過一個基類的指針（或者引用）來調用不同子類的方法。
那么，現在的問題是，這個功能是怎樣實現的呢？我們可以先來大概猜測一下：對于一般的方法調用，到了匯編代碼這一層次的時候，一般都是使用 Call funcaddr
這樣的指令進行調用，其中funcaddr是要調用函數的地址。按理來說，當我使用指針pShape來調用Draw的時候，編譯器應該將Shape::Draw的地址賦給funcaddr，然后Call
指令就可以直接調用Shape::Draw了，這就跟用pShape來調用Shape::Erase一樣。但是，運行結果卻告訴我們，編譯器賦給funcaddr的值卻是Circle::Drawde的值。這就說明，編譯器在對待Draw方法和Erase方法時使用了雙重標準。那么究竟是誰有這么大的法力，使編譯器這個鐵面無私的判官都要另眼相看呢？virtual！！
Clever！！正是virtual這個關鍵字一手導演了這一出“乾坤大挪移”的好戲。說道這里，我們先要明確兩個概念：靜態綁定和動態綁定。
1、靜態綁定（static
bingding），也叫早期綁定，簡單來說就是編譯器在編譯期間就明確知道所要調用的方法，并將該方法的地址賦給了Call指令的funcaddr。因此，運行期間直接使用Call指令就可調用到相應的方法。
2、動態綁定（dynamic
binding），也叫晚期綁定，與靜態綁定不同，在編譯期間，編譯器并不能明確知道究竟要調用的是哪一個方法，而這，要知道運行期間使用的具體是哪個對象才能決定。
好了，有了這兩個概念以后，我們就可以說，virtual的作用就是告訴編譯器：我要進行動態綁定！編譯器當然會尊重你的意見，而且為了完成你這個要求，編譯器還要做很多的事情：編譯器自動在聲明了virtual方法的類中插入一個指針vptr和一個數據結構VTable（vptr用以指向VTable；VTable是一個指針數組，里面存放著函數的地址），并保證二者遵守下面的規則：
1、VTable中只能存放聲明為virtual的方法，其它方法不能存放在里面。在上面的例子中，Shape的VTable中就只有Draw，MoveTo和~Shape。方法Erase的地址并不能存放在VTable中。此外，如果方法是純虛函數，如
Draw，那么同樣要在VTable中保留相應的位置，但是由于純虛函數沒有函數體，因此該位置中并不存放Draw的地址，而是可以選擇存放一個出錯處理的函數的地址，當該位置被意外調用時，可以用出錯函數進行相應的處理。
2、派生類的VTalbe中記錄的從基類中繼承下來的虛函數地址的索引號必須跟該虛函數在基類VTable中的索引號保持一致。如在上例中，如果在Shape的VTalbe中，Draw為
1 號， MoveTo 2 號，~Shape為 3 號，那么，不管這些方法在Circle中是按照什么順序定義的，Circle的VTable中都必須保證Draw為
1 號，MoveTo為 2號。至于 3號，這里是~Circle。為什么不是~Shape啊？嘿嘿，忘啦，析構函數不會繼承的。
3、vptr是由編譯器自動插入生成的，因此編譯器必須負責為其進行初始化。初始化的時間選在對象創建時，而地點就在構造函數中。因此，編譯器必須保證每個類至少有一個構造函數，若沒有，自動為其生成一個默認構造函數。
4、vptr通常放在對象的起始處，也就是Addr(obj) == Addr(obj.vptr)。
你看，天下果然沒有免費的午餐，為了實現動態綁定，編譯器要為我們默默干了這么多的臟話累活。如果你想體驗一下編譯器的辛勞，那么可以嘗試用C語言模擬一下上面的行為，【1】中就有這么一個例子。好了，現在萬事具備，只欠東風了。編譯，連接，載入，GO！當程序執行到
pShape->Draw()的時候，上面的設施也開始起作用了。。
前面已經提到，晚期綁定時之所以不能確定調用哪個函數，是因為具體的對象不確定。好了，當運行到pShape->Draw()時，對象出來了，它由pShape指針標出。我們找到這個對象后，就可以找到它里面的vptr（在對象的起始處），有了vptr后，我們就找到了VTable，調用的函數就在眼前了。。等等，VTable中方法那么多，我究竟使用哪個呢？不用著急，編譯器早已為我們做好了記錄：編譯器在創建VTable時，已經為每個virtual函數安排好了座次，并且把這個索引號記錄了下來。因此，當編譯器解析到pShape->Draw()的時候，它已經悄悄的將函數的名字用索引號來代替了。這時候，我們通過這個索引號就可以在VTable中得到一個函數地址，Call
it！
在這里，我們就體會到為什么會有第二條規定了，通常，我們都是用基類的指針來引用派生類的對象，但是不管具體對象是哪個派生類的，我們都可以使用相同的索引號來取得對應的函數實現。
現實中有一個例子其實跟這個蠻像的：報警電話有110，119，120（VTable中不同的方法）。不同地方的人撥打不同的號碼所產生的結果都是不一樣的。譬如，在三環外的一個人（具體對象）跟一環內的一個人（另外一個具體對象）打119，最后調用的消防隊肯定是不一樣的，這就是多態了。這是怎么實現的呢，每個人都知道一個報警中心（VTable，里面有三個方法
110，119，120）。如果三環外的一個人需要火警搶險（一個具體對象）時，它就撥打119，但是他肯定不知道最后是哪一個消防隊會出現的。這得有報警中心來決定，報警中心通過這個具體對象（例子中就是具體位置了）以及他說撥打的電話號碼（可以理解成索引號），報警中心可以確定應該調度哪一個消防隊進行搶險（不同的動作）。
這樣，通過vptr和VTable的幫助，我們就實現了C++的動態綁定。當然，這僅僅是單繼承時的情況，多重繼承的處理要相對復雜一點，下面簡要說一下最簡單的多重繼承的情況，至于虛繼承的情況，有興趣的朋友可以看看
Lippman的《Inside the C++ Object
Model》，這里暫時就不展開了。（主要是自己還沒搞清楚，況且現在多重繼承都不怎么使用了，虛繼承應用的機會就更少了）
首先，我要先說一下多重繼承下對象的內存布局，也就是說該對象是如何存放本身的數據的。
class
Cute
{
public:
int i;
virtual void cute(){ cout<<"Cute
cute"<<endl; }
};
class
Pet
{
public:
int j;
virtual void say(){ cout<<"Pet
say"<<endl; }
};
class
Dog : public Cute,public Pet
{
public:
int z;
void cute(){
cout<<"Dog cute"<<endl; }
void say(){ cout<<"Dog
say"<<endl; }
};
在上面這個例子中，一個Dog對象在內存中的布局如下所示：
|
Dog
|
|
Vptr1
|
|
Cute::i
|
|
Vptr2
|
|
Pet::j
|
|
Dog::z
|
也就是說，在Dog對象中，會存在兩個vptr,每一個跟所繼承的父類相對應。如果我們要想實現多態，就必須在對象中準確地找到相應的vptr，以調用不同的方法。但是，如果根據單繼承時的邏輯，也就是vptr放在指針指向位置的起始處，那么，要在多重繼承情況下實現，我們必須保證在將一個派生類的指針隱式或者顯式地轉換成一個父類的指針時，得到的結果指向相應派生類數據在Dog對象中的起始位置。幸好，這工作編譯器已經幫我們完成了。上面的例子中，如果Dog向上轉換成Pet的話，編譯器會自動計算Pet數據在Dog對象中的偏移量，該偏移量加上Dog對象的起始位置，就是Pet數據的實際地址了。
int
main()
{
Dog* d = new Dog();
cout<<"Dog object addr :
"<<d<<endl;
Cute* c = d;
cout<<"Cute type addr :
"<<c<<endl;
Pet* p = d;
cout<<"Pet type addr :
"<<p<<endl;
delete d;
}
output:
Dog
object addr : 0x3d24b0
Cute type addr : 0x3d24b0
Pet type addr :
0x3d24b8 // 正好指向Dog對象的vptr2處，也就是Pet的數據
好了，既然編譯器幫我們自動完成了不同父類的地址轉換，我們調用虛函數的過程也就跟單繼承統一起來了：通過具體對象，找到vptr（通常指針的起始位置，因此Cute找到的是vptr1，而Pet找到的是vptr2），通過vptr，我們找到VTable，然后根據編譯時得到的VTable索引號，我們取得相應的函數地址，接著就可以馬上調用了。
在這里，順便也提一下兩個特殊的方法在多態中的特別之處吧：第一個是構造函數，在構造函數中調用虛函數是不會有多態行為的，例子如下：
class
Pet
{
public:
Pet(){ sayHello(); }
void say(){ sayHello();
}
virtual void sayHello()
{
cout<<"Pet
sayHello"<<endl;
}
};
class
Dog : public Pet
{
public:
Dog(){};
void sayHello()
{
cout<<"Dog sayHello"<<endl;
}
};
int
main()
{
Pet* p = new Dog();
p->sayHello();
delete
p;
}
output:
Pet
sayHello //直接調用的是Pet的sayHello()
Dog sayHello //多態
第二個就是析構函數，使用多態的時候，我們經常使用基類的指針來引用派生類的對象，如果是動態創建的，對象使用完后，我們使用delete來釋放對象。但是，如果我們不注意的話，會有意想不到的情況發生。
class
Pet
{
public:
~Pet(){ cout<<"Pet destructor"<<endl;
}
//virtual ~Pet(){ cout<<"Pet virtual destructor"<<endl;
}
};
class
Dog : public Pet
{
public:
~Dog(){ cout<<"Dog
destructor"<<endl;};
//virtual ~Dog(){ cout<<"Dog virtual
destructor"<<endl; }
};
int
main()
{
Pet* p = new Dog();
delete p;
}
output：
Pet
destructor //糟了，Dog的析構函數沒有調用，memory
leak!
如果我們將析構函數改成virtual以后，結果如下
Dog virtual destructor
Pet virtual
destructor // That's OK!
所以，如果一個類設計用來被繼承的話，那么它的析構函數應該被聲明為virtual的。