C++對象模型之RTTI的實現(xiàn)原理
RTTI是Runtime Type Identification的縮寫，意思是運行時類型識別。C++引入這個機制是為了讓程序在運行時能根據(jù)基類的指針或引用來獲得該指針或引用所指的對象的實際類型。但是現(xiàn)在RTTI的類型識別已經(jīng)不限于此了，它還能通過typeid操作符識別出所有的基本類型(int，指針等)的變量對應(yīng)的類型。
C++通過以下的兩個操作提供RTTI：
- typeid運算符，該運算符返回其表達式或類型名的實際類型。
- dynamic_cast運算符，該運算符將基類的指針或引用安全地轉(zhuǎn)換為派生類類型的指針或引用。
下面分別詳細地說明這兩個操作的實現(xiàn)方式。
注所有的測試代碼的測試環(huán)境均為：32位Ubuntu 14.04 g++ 4.8.2，若在不同的環(huán)境中進行測試，結(jié)果可能有不同。
1、typeid運算符
typeid運算符，后接一個類型名或一個表達式，該運算符返回一個類型為std::tpeinf的對象的const引用。type_info是std中的一個類，它用于記錄與類型相關(guān)的信息。類type_info的定義大概如下：
- class type_info
- {
- public:
- virtual ~type_info();
- bool operator==(const type_info&)const;
- bool operator!=(const type_info&)const;
- bool before(const type_info&)const;
- const char* name()const;
- private:
- type_info(const type_info&);
- type_info& operator=(const type_info&);
- // data members
- };
至于data members部分，不同的編譯器會有所不同，但是都必須提供最小量的信息是class的真實名稱和在type_info對象之間的某些排序算法(通過before()成員函數(shù)提供)，以及某些形式的描述器，用來表示顯式的類的類型和該類的任何子類型。
從上面的定義也可以看到，type_info提供了兩個對象的相等比較操作，但是用戶并不能自己定義一個type_info的對象，而只能通過typeid運算符返回一個對象的const引用來使用type_info的對象。因為其只聲明了一個構(gòu)造函數(shù)(復(fù)制構(gòu)造函數(shù))且為private，所以編譯器不會合成任何的構(gòu)造函數(shù)，而且賦值操作運行符也為private。這兩個操作就完全禁止了用戶對type_info對象的定義和復(fù)制操作，用戶只能通過指向type_info的對象的指針或引用來使用該類。
下面說說，typeid對靜態(tài)類型的表達式和動態(tài)類型的表達式的處理和實現(xiàn)。
1)typeid識別靜態(tài)類型
當(dāng)typeid中的操作數(shù)是如下情況之一時，typeid運算符指出操作數(shù)的靜態(tài)類型，即編譯時的類型。
- 類型名
- 一個基本類型的變量
- 一個具體的對象
- 一個指向不含有virtual函數(shù)的類對象的指針的解引用
- 一個指向不含有virtual函數(shù)的類對象的引用
靜態(tài)類型在程序的運行過程中并不會改變，所以并不需要在程序運行時計算類型，在編譯時就能根據(jù)操作數(shù)的靜態(tài)類型，推導(dǎo)出其類型信息。例如如下的代碼片斷，typeid中的操作數(shù)均為靜態(tài)類型：
- class X { ...... // 具有virtual函數(shù) };
- class XX : public X { ...... // 具有virtual函數(shù)};
- class Y { ...... // 沒有virtual函數(shù)};
- int main()
- {
- int n = 0;
- XX xx;
- Y y;
- Y *py = &y;
- // int和XX都是類型名
- cout << typeid(int).name() << endl;
- cout << typeid(XX).name() << endl;
- // n為基本變量
- cout << typeid(n).name() << endl;
- // xx所屬的類雖然存在virtual，但是xx為一個具體的對象
- cout << typeid(xx).name() << endl;
- // py為一個指針，屬于基本類型
- cout << typeid(py).name() << endl;
- // py指向的Y的對象，但是類Y不存在virtual函數(shù)
- cout << typeid(*py).name() << endl;
- return 0;
- }
2)typeid識別多態(tài)類型
當(dāng)typeid中的操作數(shù)是如下情況之一時，typeid運算符需要在程序運行時計算類型，因為其其操作數(shù)的類型在編譯時期是不能被確定的。
- 一個指向不含有virtual函數(shù)的類對象的指針的解引用
- 一個指向不含有virtual函數(shù)的類對象的引用
多態(tài)的類型是可以在運行過程中被改變的，例如，一個基類的指針，在程序運行的過程中，它可以指向一個基類對象，也可以指向該基類的派生類的對象，而typeid運算符需要在運行過程中識別出該基類指針所指向的對象的實際類型，這就需要typeid運算符在運行過程中計算其指向的對象的實際類型。例如對于以下的類定義：
- class X
- {
- public:
- X()
- {
- mX = 101;
- }
- virtual void vfunc()
- {
- cout << "X::vfunc()" << endl;
- }
- private:
- int mX;
- };
- class XX : public X
- {
- public:
- XX():
- X()
- {
- mXX = 1001;
- }
- virtual void vfunc()
- {
- cout << "XX::vfunc()" << endl;
- }
- private:
- int mXX;
- };
使用如下的代碼進行測試：
- void printTypeInfo(const X *px)
- {
- cout << "typeid(px) -> " << typeid(px).name() << endl;
- cout << "typeid(*px) -> " << typeid(*px).name() << endl;
- }
- int main()
- {
- X x;
- XX xx;
- printTypeInfo(&x);
- printTypeInfo(&xx);
- return 0;
- }
其輸出如下：
從輸出的結(jié)果可以看出，無論printTypeInfo函數(shù)中指針px指向的對象是基類X的對象，還是指向派生類XX的對象，typeid運行返回的px的類型信息都是相同的，因為px為一個靜態(tài)類型，其類型名均為PX1X。但是typeid運算符卻能正確地計算出了px指向的對象的實際類型。(注：由于C++為了保證每一個類在程序中都有一個獨一無二的類名，所以會對類名通過一定的規(guī)則進行改寫，所以在這里顯示的類名跟我們定義的有一些不一樣，如類XX的類名，被改寫成了2XX。)
那么問題來了，typeid是如何計算這個類型信息的呢?下面將重點說明這個問題。
多態(tài)類型是通過在類中聲明一個或多個virtual函數(shù)來區(qū)分的。因為在C++中，一個具備多態(tài)性質(zhì)的類，正是內(nèi)含直接聲明或繼承而來的virtual函數(shù)。多態(tài)類的對象的類型信息保存在虛函數(shù)表的索引的-1的項中，該項是一個type_info對象的地址，該type_info對象保存著該對象對應(yīng)的類型信息，每個類都對應(yīng)著一個type_info對象。下面就對這一說法進行驗證。
使用如以的代碼，對上述的類X和類XX的對象的內(nèi)存布局進行測試：
- typedef void (*FuncPtr)();
- int main()
- {
- XX xx;
- FuncPtr func;
- char *p = (char*)&xx;
- // 獲得虛函數(shù)表的地址
- int **vtbl = (int**)*(int**)p;
- // 輸出虛函數(shù)表的地址，即vptr的值
- cout << vtbl << endl;
- // 獲得type_info對象的指針，并調(diào)用其name成員函數(shù)
- cout << "\t[-1]: " << (vtbl[-1]) << " -> "
- << ((type_info*)(vtbl[-1]))->name() << endl;
- // 調(diào)用第一個virtual函數(shù)
- cout << "\t[0]: " << vtbl[0] << " -> ";
- func = (FuncPtr)vtbl[0];
- func();
- // 輸出基類的成員變量的值
- p += sizeof(int**);
- cout << *(int*)p << endl;
- // 輸出派生類的成員變量的值
- p += sizeof(int);
- cout << *(int*)p << endl;
- return 0;
- }
測試代碼，對類XX的對象的內(nèi)存布局進行測試，其輸出結(jié)果如下：
從運行結(jié)果可以看到，利用虛函數(shù)表的-1的項的地址轉(zhuǎn)換成一個type_info的指針類型，并調(diào)用name成員函數(shù)的輸出為2XX，其輸出與前面的測試代碼中利用typeid的輸出一致。從而可以知道，關(guān)于多態(tài)類型的計算是通過基類指針或引用指向的對象(子對象)的虛函數(shù)表獲得的。
從運行的結(jié)果可以知道，類XX的對象的內(nèi)存布局如下：
對于以下的代碼片斷：
- typeid(*px).name()
可能被轉(zhuǎn)換成如下的C++偽代碼，用于計算實際對象的類型：
- (*(type_info*)px->vptr[-1]).name();
在多重繼承和虛擬繼承的情況下，一個類有n(n>1)個虛函數(shù)表，該類的對象也有n個vptr，分別指向這些虛函數(shù)表，但是一個類的所有的虛函數(shù)表的索引為-1的項的值(type_info對象的地址)都是相等的，即它們都指向同一個type_info對象，這樣就實現(xiàn)了無論使用了哪一個基類的指針或引用指向其派生類的對象，都能通過相應(yīng)的虛函數(shù)表獲取到相同的type_info對象，從而得到相同的類型信息。
3)typeid的識別錯誤的情況
從第2)節(jié)可以看到，typeid對于多態(tài)類型是通過虛函數(shù)表來計算的，若一個基類的指針指向了一個派生類，而該派生類并不存在virtual函數(shù)會出現(xiàn)什么情況呢?
例如，把第2)節(jié)中的X和XX類中的virtual函數(shù)全部去掉，改成以下的代碼：
- class X
- {
- public:
- X()
- {
- mX = 101;
- }
- private:
- int mX;
- };
- class XX : public X
- {
- public:
- XX():
- X()
- {
- mXX = 1001;
- }
- private:
- int mXX;
- };
測試代碼不變，如下：
- void printTypeInfo(const X *px)
- {
- cout << "typeid(px) -> " << typeid(px).name() << endl;
- cout << "typeid(*px) -> " << typeid(*px).name() << endl;
- }
- int main()
- {
- X x;
- XX xx;
- printTypeInfo(&x);
- printTypeInfo(&xx); // 注釋1
- return 0;
- }
其輸出如下：
從輸出的結(jié)果可以看到，對于注釋1的函數(shù)調(diào)用，雖然函數(shù)中基類(X)的指針px指向一個派生類對象(XX類的對象xx)，但是typeid卻并不沒有像第2)節(jié)那樣能正確地通過指針px計算出其所指對象的實際類型。
其原因在于類XX和類X都沒有一個virtual函數(shù)，所以類XX和類X并不表現(xiàn)出多態(tài)類的性質(zhì)。所以對類的指針的解引用符合第1)節(jié)中所說的靜態(tài)類型，所以其類型信息是在編譯時就已經(jīng)確定的，并不需要在程序運行的過程中運行計算，所以其輸出的類型均為1X而沒有輸出1XX。更進一步說，是因為類X和類XX都不存在virtual函數(shù)，所以類X和XX都不存在虛函數(shù)表，所以也就沒有空間存儲跟類X和XX類型有關(guān)的type_info對象的地址。
然而在C++中即使一個類不具有多態(tài)的性質(zhì)，仍然允許把一個派生類的指針賦值給一個基類的指針，所以這個錯誤比較隱晦。
2、dynamic_cast運算符
把一個基類類型的指針或引用轉(zhuǎn)換至繼承架構(gòu)的末端某一個派生類類型的指針或引用被稱為向下轉(zhuǎn)型(downcast)。dynamic_cast運算符的作用是安全而有效地進行向下轉(zhuǎn)型。
把一個派生類的指針或引用轉(zhuǎn)換成其基類的指針或引用總是安全的，因為通過分析對象的內(nèi)存布局可以知道，派生類的對象中必然存在基類的子對象，所以通過基類的指針或引用對派生類對象進行的所有基類的操作都是合法和安全的。而向下轉(zhuǎn)型有潛在的危險性，因為基類的指針可以指向基類對象或其任何派生類的對象，而該對象并不一定是向下轉(zhuǎn)型的類型的對象。所以向下轉(zhuǎn)型遏制了類型系統(tǒng)的作用，轉(zhuǎn)換后對指針或引用的使用可能會引發(fā)錯誤的解釋或腐蝕程序內(nèi)存等錯誤。
例如對于以下的類定義：
- class X
- {
- public:
- X()
- {
- mX = 101;
- }
- virtual ~X()
- {
- }
- private:
- int mX;
- };
- class XX : public X
- {
- public:
- XX():
- X()
- {
- mXX = 1001;
- }
- virtual ~XX()
- {
- }
- private:
- int mXX;
- };
- class YX : public X
- {
- public:
- YX()
- {
- mYX = 1002;
- }
- virtual ~YX()
- {
- }
- private:
- int mYX;
- };
使用如下的測試代碼，其中的類型轉(zhuǎn)換均為向下轉(zhuǎn)型：
- int main(){ X x; XX xx; YX yx; X *px = &xx; cout << px << endl; XX *pxx = dynamic_cast<XX*>(px); // 轉(zhuǎn)換1 cout << pxx << endl; YX *pyx = dynamic_cast<YX*>(px); // 轉(zhuǎn)換2 cout << pyx << endl; pyx = (YX*)px; // 轉(zhuǎn)換3 cout << pyx << endl; pyx = static_cast<YX*>(px); // 轉(zhuǎn)換4 cout << pyx << endl; return 0;}
其運行結(jié)果如下：
運行結(jié)果分析
px是一個基類(X)的指針，但是它指向了派生類XX的一個對象。在轉(zhuǎn)換1中，轉(zhuǎn)換成功，因為px指向的對象確實為XX的對象。在轉(zhuǎn)換2中，轉(zhuǎn)換失敗，因為px指向的對象并不是一個YX對象，此時dymanic_cast返回NULL。轉(zhuǎn)換3為C風(fēng)格的類型轉(zhuǎn)換而轉(zhuǎn)換4使用的是C++中的靜態(tài)類型轉(zhuǎn)換，它們均能成功轉(zhuǎn)換，但是這個對象實際上并不是一個YX的對象，所以在轉(zhuǎn)換3和轉(zhuǎn)換4中，若繼續(xù)通過指針使用該對象必然會導(dǎo)致錯誤，所以這個轉(zhuǎn)換是不安全的。
從上述的結(jié)果可以看出在向下轉(zhuǎn)型中，只有dynamic_case才能實現(xiàn)安全的向下轉(zhuǎn)型。那么dynamic_case是如何實現(xiàn)的呢?有了上面typeid和虛函數(shù)表的知識后，這個問題并不難解釋了，以轉(zhuǎn)換1為例。
- 計算指針或引用變量所指的對象的虛函數(shù)表的type_info信息，如下：
- *(type_info*)px->vptr[-1]
- 靜態(tài)推導(dǎo)向下轉(zhuǎn)型的目標類型的type_info信息，即獲取類XX的type_info信息
- 比較1)和2)中獲取到的type_info信息，若2)中的類型信息與1)中的類型信息相等或是其基類類型，則返回相應(yīng)的對象或子對象的地址，否則返回NULL。
引用的情況與指針稍有不同，失敗時并不是返回NULL，而是拋出一個bad_cast異常，因為引用不能參考NULL。
