虛函數

虛函數

在某基類中聲明為 virtual 並在一個或多個派生類中被重新定義的成員函數，用法格式為：virtual 函數返回類型 函數名（參數表）函數體；實現多態性，通過指向派生類的基類指針或引用，訪問派生類中同名覆蓋成員函數。

目錄
1定義 2輸出結果 3實現
4代碼示例

定義

簡單地說，那些被virtual關鍵字修飾的成員函數，就是虛函數。虛函數的作用，用專業術語來解釋就是實現多態性（Polymorphism），多態性是將介面與實現進行分離；用形象的語言來解釋就是實現以共同的方法，但因個體差異，而採用不同的策略。下面來看一段簡單的代碼。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include
using namespace std;
class A
{
public:
void print()
{
cout<<"This is A"<
}
};
 
class B : public A
{
public:
void print()
{
cout<<"This is B"<
}
};
 
int main()
{
//為了在以後便於區分，我這段main()代碼叫做main1
A a;
B b;
a.print();
b.print();
return 0;
}

輸出結果

分別是“This is A”、“This is B”。
通過class A和class B的print（）這個介面，可以看出這兩個class因個體的差異而採用了不同的策略，但這並不是多態性行為（使用的是不同類型的指針），沒有用到虛函數的功能。現在把main（）處的代碼改一改。
1
2
3
4
5
6
7
8
9
10
11
int main()
{
//main2
A a;
B b;
A *p1 = &a;
A *p2 = &b;
p1->print();
p2->print();
return 0;
}
運行一下看看結果，結果卻是兩個This is A（錯）。
問題來了，p2明明指向的是class B的對象但卻是調用的class A的print（）函數，這不是我們所期望的結果，那麼解決這個問題就需要用到虛函數。
1
2
3
4
5
6
7
8
9
10
class A
{
public:
virtual void print(){cout<<"This is A"<
};
class B : public A
{
public:
void print(){cout<<"This is B"<
};
毫無疑問，class A的成員函數print（）已經成了虛函數，那麼class B的print（）成了虛函數了嗎？回答是Yes，我們只需在把基類的成員函數設為virtual，其派生類的相應的函數也會自動變為虛函數。所以，class B的print()也成了虛函數。那麼對於在派生類的相應函數前是否需要用virtual關鍵字修飾，那就是你自己的問題了（語法上可加可不加，不加的話編譯器會自動加上，但為了閱讀方便和規範性，建議加上）。
現在重新運行main2的代碼，這樣輸出的結果就是This is A和This is B了。
現在來消化一下，我作個簡單的總結，指向基類的指針在操作它的多態類對象時，會根據不同的類對象，調用其相應的函數，這個函數就是虛函數。指針在操作它的多態類對象時，會根據不同的類對象，調用其相應的函數，這個函數就是虛函數。

實現

（如果你沒有看過《Inside The C++ Object Model》這本書，但又急切想知道，那你就應該從這裡開始）
虛函數是如何做到因對象的不同而調用其相應的函數的呢？現在我們就來剖析虛函數。我們先定義兩個類
1
2
3
4
5
6
7
8
9
10
class A{//虛函數示例代碼
public:
virtual void fun(){cout<<1<
virtual void fun2(){cout<<2<
};
class B : public A{
public:
void fun(){cout<<3<
void fun2(){cout<<4<
};
通過圖1，可以看到這兩個vtbl分別為class A和class B服務。現在有了這個模型之後，我們來分析下面的代碼。
A *p=new A;
p->fun();
毫無疑問，調用了A::fun（），但是A::fun（）是如何被調用的呢？它像普通函數那樣直接跳轉到函數的代碼處嗎？No，其實是這樣的，首先是取出vptr的值，這個值就是vtbl的地址，再根據這個值來到vtbl這裡，由於調用的函數A::fun（）是第一個虛函數，所以取出vtbl中第一個Slot的值即為第一個虛函數的地址（在不同的編譯器下第一個vtbl布局不完全相同，在VS2008中第一個Slot的值為指向第一個虛函數的指針，而其他編譯器中也可能出現第一個Slot中值為type_info對象的指針），這個值就是A::fun（）的地址了，最後調用這個函數。現在我們可以看出來了，只要vptr不同，指向的vtbl就不同，而不同的vtbl里裝著對應類的虛函數地址，所以這樣虛函數就可以完成它的任務。
而對於class A和class B來說，他們的vptr指針存放在何處呢？其實這個指針就放在他們各自的實例對象里。由於class A和class B都沒有數據成員，所以他們的實例對象里就只有一個vptr指針。通過上面的分析，現在我們來實作一段代碼，來描述這個帶有虛函數的類的簡單模型。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include
using namespace std;
//將上面“虛函數示例代碼”添加在這裡
int main()
{
void(*fun)(A*);
A *p=new B;
long lVptrAddr;
memcpy(&lVptrAddr,p,4);
memcpy(&fun,reinterpret_cast(lVptrAddr),4);
fun(p);
delete p;
system("pause");
return 0;
}
用VC或Dev-C++編譯運行一下，看看結果是不是輸出3。現在一步一步開始分析。
void (*fun)(A*); 這段定義了一個函數指針名字叫做fun，而且有一個A*類型的參數，這個函數指針待會兒用來保存從vtbl里取出的函數地址。
A* p=new B; new B是向內存（內存分5個區：全局名字空間，自由存儲區，寄存器，代碼空間，棧）自由存儲區申請一個內存單元的地址然後隱式地保存在一個指針中。然後把這個地址賦值給A類型的指針P。
.
long lVptrAddr; 這個long類型的變數待會兒用來保存vptr的值。
memcpy(&lVptrAddr,p,4); 前面說了，他們的實例對象里只有vptr指針，所以我們就放心大膽地把p所指的4bytes內存里的東西複製到lVptrAddr中，所以複製出來的4bytes內容就是vptr的值，即vtbl的地址。
現在有了vtbl的地址了，那麼我們現在就取出vtbl第一個slot里的內容。
memcpy(&fun,reinterpret_cast(lVptrAddr),4); 取出vtbl第一個slot里的內容，並存放在函數指針fun里。需要注意的是lVptrAddr裡面是vtbl的地址，但lVptrAddr不是指針，所以我們要把它先轉變成指針類型
fun(p); 這裡就調用了剛才取出的函數地址里的函數，也就是調用了B::fun（）這個函數，也許你發現了為什麼會有參數p，其實類成員函數調用時，會有個this指針，這個p就是那個this指針，只是在一般的調用中編譯器自動幫你處理了而已，而在這裡則需要自己處理。
delete p; 釋放由p指向的自由空間；
system("pause"); 屏幕暫停；
如果調用B::fun2（）怎麼辦？那就取出vtbl的第二個slot里的值就行了。
memcpy(&fun,reinterpret_cast(lVptrAddr+4),4); 為什麼是加4呢？因為一個指針的長度是4bytes(32位機上，64位長度8bytes)，所以加4。或者memcpy(&fun,reinterpret_cast(lVptrAddr)+1,4); 這更符合數組的用法，因為lVptrAddr被轉成了long*型別，所以+1就是往後移sizeof(long）的長度。

代碼示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include
using namespace std;
class A{//虛函數示例代碼2
public:
virtual void fun(){cout<<"A::fun"<
virtual void fun2(){cout<<"A::fun2"<
};
class B : public A{
public:
void fun(){cout<<"B::fun"<
void fun2(){cout<<"B::fun2"<
};//end//虛函數示例代碼2
int main()
{
void(A::*fun)();//定義一個函數指針
A *p=new B;
fun=&A::fun;
(p->*fun)();
fun=&A::fun2;
(p->*fun)();
delete p;
system("pause");
return 0;
}
誤區
你能估算出結果嗎？如果你估算出的結果是A::fun和A::fun2，呵呵，恭喜恭喜，你中圈套了。其實真正的結果是B::fun和B::fun2，如果你想不通就接著往下看。給個提示，&A::fun和&A::fun2是真正獲得了虛函數的地址嗎？
首先我們回到第二部分，通過段實作代碼，得到一個“通用”的獲得虛函數地址的方法。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include
using namespace std;
//將上面“虛函數示例代碼2”添加在這裡
void CallVirtualFun(void*pThis,intindex=0)
{
void(*funptr)(void*);
long lVptrAddr;
memcpy(&lVptrAddr,pThis,4);
memcpy(&funptr,reinterpret_cast(lVptrAddr)+index,4);
funptr(pThis);//調用
}
int main()
{
A *p = new B;
CallVirtualFun(p);//調用虛函數p->fun()
CallVirtualFun(p,1);//調用虛函數p->fun2()
system("pause");
return 0;
}
CallVirtualFun
現在我們擁有一個“通用”的CallVirtualFun方法。
這個通用方法和第三部分開始處的代碼有何聯繫呢？聯繫很大。由於A::fun（）和A::fun2（）是虛函數，所以&A::fun和&A::fun2獲得的不是函數的地址，而是一段間接獲得虛函數地址的一段代碼的地址，我們形象地把這段代碼看作那段CallVirtualFun。編譯器在編譯時，會提供類似於CallVirtualFun這樣的代碼，當你調用虛函數時，其實就是先調用的那段類似CallVirtualFun的代碼，通過這段代碼，獲得虛函數地址后，最後調用虛函數，這樣就真正保證了多態性。同時大家都說虛函數的效率低，其原因就是，在調用虛函數之前，還調用了獲得虛函數地址的代碼。
其他信息
定義虛函數的限制：（1）非類的成員函數不能定義為虛函數，類的成員函數中靜態成員函數和構造函數也不能定義為虛函數，但可以將析構函數定義為虛函數。實際上，優秀的程序員常常把基類的析構函數定義為虛函數。因為，將基類的析構函數定義為虛函數后，當利用delete刪除一個指向派生類定義的對象指針時，系統會調用相應的類的析構函數。而不將析構函數定義為虛函數時，只調用基類的析構函數。
（2）只需要在聲明函數的類體中使用關鍵字“virtual”將函數聲明為虛函數，而定義函數時不需要使用關鍵字“virtual”。
（3）當將基類中的某一成員函數聲明為虛函數后，派生類中的同名函數（函數名相同、參數列表完全一致、返回值類型相關）自動成為虛函數。
（4）如果聲明了某個成員函數為虛函數，則在該類中不能出現和這個成員函數同名並且返回值、參數個數、類型都相同的非虛函數。在以該類為基類的派生類中，也不能出現和這個成員函數同名並且返回值、參數個數、類型都相同的非虛函數。
虛函數聯繫到多態，多態聯繫到繼承。所以本文中都是在繼承層次上做文章。沒了繼承，什麼都沒得談。
最後說明
本文的代碼可以用VC6和Dev-C++4.9.8.0通過編譯，且運行無問題。其他的編譯器不敢保證。其中的類比方法只能看成模型，因為不同的編譯器的底層實現是不同的。例如this指針，Dev-C++的gcc就是通過壓棧，當作參數傳遞，而VC的編譯器則通過取出地址保存在ecx中。所以這些類比方法不能當作具體實現。

基本信息

中文名
虛函數
外文名
virtual function
定義
被virtual關鍵字修飾的成員函數
作用
實現多態性
聲明
virtual
領域
數學
關鍵
用指向基類的指針或引用操作對象
形象解釋
求同存異