C++之:虛函數表


一、文章來由

虛函數表究竟存放在哪里?

二、概念

C++中的虛函數的作用主要是實現了多態的機制。關於多態,簡而言之就是用父類型別的指針指向其子類的實例,然后通過父類的指針調用實際子類的成員函數。這種技術可以讓父類的指針有“多種形態”,這是一種泛型技術。所謂泛型技術,說白了就是試圖使用不變的代碼來實現可變的算法。比如:模板技術,RTTI技術,虛函數技術,要么是試圖做到在編譯時決議,要么試圖做到運行時決議。

對C++ 了解的人都應該知道虛函數(Virtual Function)是通過一張虛函數表(Virtual Table)來實現的。簡稱為V-Table。在這個表中,主是要一個類的虛函數的地址表,這張表解決了繼承、覆蓋的問題,保證其容真實反應實際的函數。這樣,在有虛函數的類的實例中這個表被分配在了這個實例的內存中,所以,當我們用父類的指針來操作一個子類的時候,這張虛函數表就顯得由為重要了,它就像一個地圖一樣,指明了實際所應該調用的函數。這里我們着重看一下這張虛函數表。C++的編譯器應該是保證:虛函數表的指針存在於對象實例中最前面的位置(這是為了保證取到虛函數表的有最高的性能——如果有多層繼承或是多重繼承的情況下)。 這意味着我們通過對象實例的地址得到這張虛函數表,然后就可以遍歷其中函數指針,並調用相應的函數。

class Base {
public:
virtual void f() { cout << "Base::f" << endl; }
virtual void g() { cout << "Base::g" << endl; }
virtual void h() { cout << "Base::h" << endl; }

};

int main()
{
//freopen("input.txt","r",stdin);

typedef void(*Fun)(void);
Base b;

Fun pFun = NULL;

cout << "虛函數表地址:" << (int*)(&b) << endl;
cout << "虛函數表 — 第一個函數地址:" << (int*)(*(int*)(&b)) << endl;

// Invoke virtual functions

pFun = (Fun)*((int*)*(int*)(&b)); // Base::f()
pFun();
pFun = (Fun)*((int*)*(int*)(&b)+1); // Base::g()
pFun();
pFun = (Fun)*((int*)*(int*)(&b)+2); // Base::h()
pFun();

return 0;
}

vs2012 環境下輸出:

這里寫圖片描述

通過這個示例,我們可以看到,我們可以通過強行把 &b 轉成 int*,取得虛函數表的地址,然后,再次取址就可以得到第一個虛函數的地址了,也就是Base::f(),這在上面的程序中得到了驗證(把int* 強制轉成了函數指針)。

Base 實例虛表結構圖如下:

這里寫圖片描述

注意:在上面這個圖中,虛函數表的最后多加了一個結點,這是虛函數表的結束結點,就像字符串的結束符“/0”一樣,其標志了虛函數表的結束。這個結束標志的值在不同的編譯器下是不同的。在WinXP+VS2003下,這個值是NULL。而在Ubuntu 7.10 + Linux 2.6.22 + GCC 4.1.3下,這個值是如果1,表示還有下一個虛函數表,如果值是0,表示是最后一個虛函數表。

而且,只要繼承父類的虛函數,其子類不論寫不寫virtual都是虛函數。

class Base {
public:
virtual void f() { cout << "Base::f" << endl; }

};

class Base2 : public Base{
public:
void f() { cout << "Base2::f" << endl; }
};

class Derive : public Base2{

public:
void f() { cout << "Derive::f" << endl; }
};

typedef void(*Fun)(void);

int main() {
Base2 *b2 = new Derive;

b2->f();

return 0;
}

輸出:
Derive::f

三、不同情況下的虛表

下面沒有覆蓋父類的虛函數是毫無意義的。之所以要講述沒有覆蓋的情況,主要目的是為了給一個對比。在比較之下,可以更加清楚地知道其內部的具體實現。

1、一般繼承(無虛函數覆蓋)

這里寫圖片描述

對於實例:Derive d; 的虛函數表如下

這里寫圖片描述

1)虛函數按照其聲明順序放於表中。

2)父類的虛函數在子類的虛函數前面。

2、一般繼承(有虛函數覆蓋)

這里寫圖片描述

對於派生類的實例,其虛函數表為

這里寫圖片描述

1)覆蓋的f()函數被放到了虛表中原來父類虛函數的位置。

2)沒有被覆蓋的函數依舊。

3、多重繼承(無虛函數覆蓋)

這里寫圖片描述

對於子類實例中的虛函數表為

這里寫圖片描述

1) 每個父類都有自己的虛表。

2) 子類的成員函數被放到了第一個父類的表中。(所謂的第一個父類是按照聲明順序來判斷的)

4、多重繼承(有虛函數覆蓋)

這里寫圖片描述

子類虛函數結構

這里寫圖片描述

    Derive d;
Base1 *b1 = &d;
Base2 *b2 = &d;
Base3 *b3 = &d;
b1->f(); //Derive::f()
b2->f(); //Derive::f()
b3->f(); //Derive::f()

b1->g(); //Base1::g()
b2->g(); //Base2::g()
b3->g(); //Base3::g()

問:那子類和父類虛函數表維護的是一樣的嗎?或者說上面子類自己的虛函數放在自己的表中嗎?

class Base {
public:
virtual void f() { cout << "Base::f" << endl; }
virtual void g() { cout << "Base::g" << endl; }
};

class Derive:public Base
{
public:
void f(){ cout << "Derive::f" << endl; }
virtual void f1() { cout << "Derive::f1" << endl; }

};

int main()
{
//freopen("input.txt","r",stdin);

typedef void(*Fun)(void);

Base b;
Fun bFun = (Fun)*((int*)*(int*)(&b));
bFun();
bFun = (Fun)*((int*)*(int*)(&b)+1);
bFun();
cout<<bFun<<endl;

Derive d;
Fun dFun = (Fun)*((int*)*(int*)(&d));
dFun();
dFun = (Fun)*((int*)*(int*)(&d)+1);
dFun();
dFun = (Fun)*((int*)*(int*)(&d)+2);
dFun();
cout<<dFun<<endl;

return 0;
}

四、虛函數表安全性

1、通過父類型的指針訪問子類自己的虛函數

我們知道,子類沒有覆蓋父類的虛函數是一件毫無意義的事情。雖然在上面的圖中我們可以看到 Base1 的虛表中有Derive的虛函數,但我們根本不可能使用下面的語句來調用子類的自有虛函數:

Base1 *b1 = new Derive();
b1->f1(); //編譯出錯

任何妄圖使用父類指針想調用子類中的未覆蓋父類的成員函數的行為都會被編譯器視為非法,所以,這樣的程序根本無法編譯通過。但在運行時,我們可以通過指針的方式訪問虛函數表來達到違反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;
}

2、訪問non-public的虛函數

另外,如果父類的虛函數是private或是protected的,但這些非public的虛函數同樣會存在於虛函數表中,所以,我們同樣可以使用訪問虛函數表的方式來訪問這些non-public的虛函數,這是很容易做到的。

如:

class Base {
private:
virtual void f() { cout << "Base::f" << endl; }

};

class Derive : public Base{

};

typedef void(*Fun)(void);

void main() {
Derive d;
Fun pFun = (Fun)*((int*)*(int*)(&d)+0);
pFun();
}

VC查看虛函數表

我們可以在VC的IDE環境中的Debug狀態下展開類的實例就可以看到虛函數表了(並不是很完整的)

這里寫圖片描述

附:基礎回顧

1、多態

概念:

多態性就是指同樣的消息被類的不同的對象接收時導致的完全不同的行為的一種現象。這里所說的消息即對類成員函數的調用。多態實質是一個函數名稱的多種形態。

C++兩種類型多態:

(1)編譯時多態是通過靜態聯編實現的;

(2)運行時多態則是通過動態聯編實現的。

函數聯編:

對一個函數的調用,在編譯或運行時確定將其連接到相應的函數體的代碼,實質是把一個標示名與一個存儲地址(函數代碼段入口)聯系在一起的過程。

2、虛函數

C++中的動態聯編是通過虛函數實現的,虛函數必須存在於繼承的環境下。

當一個類的成員函數說明為虛函數后,就可以在該類的(直接或間接)派生類中定義與其基類虛函數原型相同注意是函數原型一定要完全相同,否則會隱藏該虛函數)的函數。

虛函數可以在一個或多個派生類中被重新定義,要求在派生類中重新定義時,必須與基類中的函數原型完全相同,包括函數名、返回類型、參數個數和參數類型的順序。這時無論在派生類的相應成員函數前是否加上關鍵字virtual,都將視其為虛函數,如果函數原型不同,只是函數名相同,C++將視其為一般的函數重載,而不是虛函數。只有類的成員函數才能聲明為虛函數,全局函數及靜態成員函數不能聲明為虛函數。

3、純虛函數

純虛函數是在基類中只聲明虛函數而不給出具體的函數定義體,將它的具體定義放在各派生類中,稱此虛函數為純虛函數。

通過該基類的指針或引用就可以調用所有派生類的虛函數,基類只是用於繼承,僅作為一個接口,具體功能在派生類中實現.

純虛函數的聲明如下:(注:要放在基類的定義體中)

 virtual 函數原型=0;

注意:

(1)聲明了純虛函數的類,稱為抽象類;

(2)抽象類中可以有多個純虛函數;

(3)不能聲明抽象類的對象,但可以聲明指向抽象類的指針變量和引用變量

(4)抽象類也可以定義其他非純虛函數;

(5)如果派生類中沒有重新定義基類中的純虛函數,則在派生類中必須再將該虛函數聲明為純虛函數;

(6)從抽象類可以派生出具體或抽象類,但不能從具體類派生出抽象類(這條在vs2012上實驗是錯誤的,詳見后面代碼);

(7)在一個復雜的類繼承結構中,越上層的類抽象程度越高,有時甚至無法給出某些成員函數的實現,顯然,抽象類是一種特殊的類,它一般處於類繼承結構的較外層;

(8)引入抽象類的目的,主要是為了能將相關類組織在一個類繼承結構中,並通過抽象類來為這些相關類提供統一的操作接口。

驗證第六條:

class Base {
public:
void f() { cout << "Base::f" << endl; }

};

class Base2 : public Base{
public:
virtual void g()=0;
};

class Derive : public Base2{

public:
void g() { cout << "Derive::g" << endl; }
};

int main() {
Base2 *b2 = new Derive;

b2->f();
b2->g();

return 0;
}

最后輸出:
Base::f
Derive::g

說明也可以從具體類派生抽象類。

c++純虛函數調用

Inside the C++ Object Model

首先,必須清楚的是純虛函數本身是不應該被調用的!因為純虛函數是用來定義接口的,有時候基類自己找不到一個合情合理的實現,所以用虛函數的形式聲明,讓他的子類去做具體的實現。因此,如果純虛函數被調用了,那一定是你的程序里出現了邏輯上的錯誤,這是我們在工作中需要了解和避免的。

class Base{
public:
virtual void foo()=0;
Base() { foo(); } // 調用純虛函數
};
class Derived: Base{
void foo() { }
};
int main() {
Derived d;
}

很幸運的,編譯器能發現錯誤並向你吐槽,以下是我使用CodeBlocks(自帶MinGw的,含基於gcc 4.7.1的編譯器)編譯得到的一個警告和一個鏈接錯誤:

編譯警告:warning: pure virtual 'virtual void Base::foo()' called from constructor
鏈接錯誤:undefined reference to `Base:
:foo()'

但是很不幸的,實際的應用中代碼往往復雜得多,使得編譯器無法在編譯的時候發現問題。修改上面的代碼如下,就可以成功的調用到虛函數了:

class Base{
public:
virtual void foo()=0;
Base() { call_foo();}
void call_foo() { foo(); }
};

class Derived: Base{
void foo() { }
};

int main() {
Derived d;
}

運行后得到的結果為:

這里寫圖片描述

總結起來,其實還是

“Item 9: Never call virtual functions during construction or destruction.” ( The third edition of Scott Meyers’ popular book, Effective C++).

最后順便提一下,在 C++ 11 的標准文檔【ISO/IEC 14882:2011(E)】中,也有相關的描述:

(10.4.6)” Member functions can be called from a constructor (or destructor) of an abstract class; the effect of making a virtual call (10.3) to a pure virtual function directly or indirectly for the object being created (or destroyed) from such a constructor (or destructor) is undefined.”

也就是說,純虛函數調用的行為是未定義的,而 gcc 的默認實現則是終止程序,輸出相關的信息。

參考鏈接:
http://www.artima.com/cppsource/nevercall.html
http://blogs.msdn.com/b/oldnewthing/archive/2004/04/28/122037.aspx
參考書籍:
Effective C++, 3rd Edition, Scott Meyers
ISO/IEC 14882:2011(E)


參考資料

[1] http://my.oschina.net/hnuweiwei/blog/280894?fromerr=4qwE4QQr

[2] http://blog.csdn.net/haoel/article/details/1948051

[3] http://www.cnblogs.com/Pony279/archive/2013/06/04/3117955.html


注意!

本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。



C++虛函數與虛函數表 C++之虛函數表 C++ 虛函數表研究 (一) 單繼承 C++進階之虛函數表 C++虛函數表分析 C++虛函數表匯總 C++虛函數表剖析 C++ 知道虛函數表的存在 C++ 虛函數表解析 C++虛函數表解析
 
粤ICP备14056181号  © 2014-2021 ITdaan.com