關于C++的RTTI

RTTI(Run-Time Type Identification)是面向對象程序設計中一種重要的技術。現行的C++標準對RTTI已經有了明確的支持。不過在某些情況下出于特殊的開發需要，我們需要自己編碼來實現。本文介紹了一些關于RTTI的基礎知識及其原理和實現。
RTTI需求：

　　和很多其他語言一樣，C++是一種靜態類型語言。其數據類型是在編譯期就確定的，不能在運行時更改。然而由于面向對象程序設計中多態性的要求，C++中的指針或引用(Reference)本身的類型，可能與它實際代表(指向或引用)的類型并不一致。有時我們需要將一個多態指針轉換為其實際指向對象的類型，就需要知道運行時的類型信息，這就產生了運行時類型識別的要求。

　　C++對RTTI的支持：

　　C++提供了兩個關鍵字typeid和dynamic_cast和一個type_info類來支持RTTI：

　　dynamic_cast操作符：它允許在運行時刻進行類型轉換，從而使程序能夠在一個類層次結構安全地轉換類型。dynamic_cast提供了兩種轉換方式，把基類指針轉換成派生類指針，或者把指向基類的左值轉換成派生類的引用。見下例講述：

void company::payroll(employee *pe) {
//對指針轉換失敗，dynamic_cast返回NULL
if(programmer *pm=dynamic_cast(pe)){
pm->bonus();
}
}
void company::payroll(employee &re) {
try{
//對引用轉換失敗的話，則會以拋出異常來報告錯誤
programmer &rm=dynamic_cast(re);
pm->bonus();
}
catch(std::bad_cast){

}
}

　　這里bonus是programmer的成員函數，基類employee不具備這個特性。所以我們必須使用安全的由基類到派生類類型轉換，識別出programmer指針。

　　typeid操作符：它指出指針或引用指向的對象的實際派生類型。

　　例如：

employee* pe=new manager;
typeid(*pe)==typeid(manager) //true
　　typeid可以用于作用于各種類型名，對象和內置基本數據類型的實例、指針或者引用，當作用于指針和引用將返回它實際指向對象的類型信息。typeid的返回是type_info類型。

　　type_info類：這個類的確切定義是與編譯器實現相關的，下面是《C++ Primer》中給出的定義(參考資料[2]中談到編譯器必須提供的最小信息量)：

class type_info {
private:
type_info(const type_info&);
type_info& operator=( const type_info& );
public:
virtual ~type_info();
int operator==( const type_info& ) const;
int operator!=( const type_info& ) const;
const char* name() const;
};

實現目標：

　　實現的方案

　　方案一：利用多態來取得指針或應用的實際類型信息

　　這是一個最簡單的方法，也是作者目前所采用的辦法。

　　實現：

enum ClassType{
UObjectClass,
URectViewClass,
UDialogClass,
……
};
class UObject{
virtual char* GetClassName() const {
return "UObject";
};
virtual ClassType TypeOfClass(){
return UObjectClass;
};
};
class UDialog{
virtual char* GetClassName() const {
return "UDialog";
};
virtual ClassType TypeOfClass(){
return UDialogClass;
};
};
　　示例：

UObject po=new UObject;
UObject pr=new URectView;
UObject pd=new UDialog;
cout << "po is a " << po->GetClassName() << endl;
cout << "pr is a " << pr->GetClassName() << endl;
cout << "pd is a " << pd->GetClassName() << endl;
cout<TypeOfClass()==UObjectClass< cout<TypeOfClass()==URectViewClass< cout<TypeOfClass()==UDialogClass< cout<TypeOfClass()==UObjectClass< cout<TypeOfClass()==UDialogClass<  
　　輸出：

po is a UObjectClass
pr is a URectViewClass
pd is a UDialogClass
true
true
true
false
false
　　這種實現方法也就是在基類中提供一個多態的方法，這個方法返回一個類型信息。這樣我們能夠知道一個指針所指向對象的具體類型，可以滿足一些簡單的要求。

　　但是很顯然，這樣的方法只實現了typeid的部分功能，還存在很多缺點：

　　1、 用戶每增加一個類必須覆蓋GetClassName和TypeOfClass兩個方法，如果忘了，會導致程序錯誤。

　　2、 這里的類名和類標識信息不足以實現dynamic_cast的功能，從這個意義上而言此方案根本不能稱為RTTI。

　　3、 用戶必須手工維護每個類的類名與標識，這限制了以庫的方式提供給用戶的可能。

　　4、 用戶必須手工添加GetClassName和TypeOfClass兩個方法，使用并不方便。

　　其中上面的部分問題我們可以采用C/C++中的宏技巧(Macro Magic)來解決，這個可以在我們的最終解決方案的代碼中看到。下面采用方案二中將予以解決上述問題。
　方案二：以一個類型表來存儲類型信息

　　這種方法考慮使用一個類結構，除了保留原有的整型類ID，類名字符串外，增加了一個指向基類TypeInfo成員的指針。

struct TypeInfo
{
char* className;
int type_id;
TypeInfo* pBaseClass;
operator== (const TypeInfo& info){
return this==&info;
}
operator!= (const TypeInfo& info){
return this!=&info;
}
};
　　從這里可以看到，以這種方式實現的RTTI不支持多重繼承。所幸多重繼承在程序設計中并非必須，而且也不推薦。下面的代碼中，我將為DP9900軟件項目組中類層次結構中的幾個類添加RTTI功能。DP9900項目中，絕大部分的類都以單繼承方式從UObject這個根類直接或間接繼承而來。這樣我們就可以從UObject開始，加入我們RTTI支持所需要的數據和方法。

class UObject
{
public:
bool IsKindOf(TypeInfo& cls); //判別某個對象是否屬于某一個類
public:
virtual int GetTypeID(){return rttiTypeInfo.type_id;}
virtual char* GetTypeName(){return rttiTypeInfo.className;}
virtual TypeInfo& GetTypeInfo(){return rttiTypeInfo;}
static TypeInfo& GetTypeInfoClass(){return rttiTypeInfo;}
private:
static TypeInfo rttiTypeInfo;
};
//依次為className、type_id、pBaseClass賦值
TypeInfo UObject::rttiTypeInfo={"UObject",0,NULL};
　　考慮從UObject將這個TypeInfo類作為每一個新增類的靜態成員，這樣一個類的所有對象將共享TypeInfo的唯一實例。我們希望能夠在程序運行之前就為type_id,className做好初始化，并讓pBaseClass指向基類的這個TypeInfo。

　　每個類的TypeInfo成員約定使用rttiTypeInfo的命名，為了避免命名沖突，我們將其作為private成員。有了基類的支持并不夠，當用戶需要RTTI支持，還需要自己來做一些事情：

　　1、 派生類需要從UObject繼承。

　　2、 添加rttiTypeInfo變量。

　　3、 在類外正確初始化rttiTypeInfo靜態成員。

　　4、 覆蓋GetTypeID、GetTypeName、GetTypeInfo、GetTypeInfoClass四個成員函數。

　　如下所示：

class UView:public UObject
{
public:
virtual int GetTypeID(){return rttiTypeInfo.type_id;}
virtual char* GetTypeName(){return rttiTypeInfo.className;}
virtual TypeInfo& GetTypeInfo(){return rttiTypeInfo;}
static TypeInfo& GetTypeInfoClass(){return rttiTypeInfo;}
private:
static TypeInfo rttiTypeInfo;
};
　　有了前三步，這樣我們就可以得到一個不算太復雜的鏈表――這是一棵類型信息構成的"樹"，與數據結構中的樹的唯一差別就是其指針方向相反。

　　這樣，從任何一個UObject的子類，順著pBaseClass往上找，總能遍歷它的所有父類，最終到達UObject。

　　在這個鏈表的基礎上，要判別某個對象是否屬于某一個類就很簡單。下面給出UObject::IsKindOf()的實現。

bool UObject::IsKindOf(TypeInfo& cls)
{
TypeInfo* p=&(this->GetTypeInfo());
while(p!=NULL){
if(p->type_id==cls.type_id)
return true;
p=p->pBaseClass;
}
return false;
}

　　有了IsKindOf的支持，dynamic_cast的功能也就可以用一個簡單的safe_cast來實現：

template
inline T* safe_cast(UObject* ptr,TypeInfo& cls)
{
return (ptr->IsKindOf(cls)?(T*)ptr:NULL);
}
　　至此，我們已經能夠從功能上完成前面的目標了，不過用戶要使用這個類庫的RTTI功能還很麻煩，要敲入一大堆對他們毫無意義的函數代碼，要在初始化rttiTypeInfo靜態成員時手工設置類ID與類名。其實這些麻煩完全不必交給我們的用戶，適當采用一些宏技巧(Macro Magic)，就可以讓C++的預處理器來替我們寫很多枯燥的代碼。關于宏不是本文的重點，你可以從最終代碼清單看到它們。下面再談談關于類ID的問題。

　　類ID

　　為了使不同類型的對象可區分，用一個給每個TypeInfo對象一個類ID來作為比較的依據是必要的。
其實對于我們這里的需求和實現方法而言，其實類ID并不是必須的。每一個支持RTTI的類都包含了一個靜態TypeInfo對象，這個對象的地址就是在進程中全局唯一。但考慮到其他一些技術如：動態對象創建、對象序列化等，它們可能會要求RTTI給出一個靜態不變的ID。在本文的實現中，對此作了有益的嘗試。

　　首先聲明一個用來產生遞增類ID的全局變量。再聲明如下一個結構，沒有數據成員，只有一個構造函數用于初始化TypeInfo的類ID：

extern int TypeInfoOrder=0;
struct InitTypeInfo
{
InitTypeInfo(TypeInfo* info)
{
info->type_id=TypeInfoOrder++;
}
};
　　為UObject添加一個private的靜態成員及其初始化：

class UObject
{
//……
private:
static InitTypeInfo initClassInfo;
};
InitTypeInfo UObject::initClassInfo(&(UObject::rttiTypeInfo));
　　并且對每一個從UObject派生的子類也進行同樣的添加。這樣您將看到，在C++主函數執行前，啟動代碼將替我們調用每一個類的initClassInfo成員的構造函數InitTypeInf:InitTypeInfo(TypeInfo* info)，而正是這個函數替我們產生并設置了類ID。InitTypeInfo的構造函數還可以替我們做其他一些有用的初始化工作，比如將所有的TypeInfo信息登錄到一個表格里，讓我們可以很方便的遍歷它。

　　但實踐與查閱資料讓我們發現，由于C++中對靜態成員初始化的順序沒有明確的規定，所以這樣的方式產生出來的類ID并非完全靜態，換一個編譯器編譯執行產生的結果可能完全不同。

　　還有一個可以考慮的方案是采用某種無沖突HASH算法，將類名轉換成為一個唯一整數。使用標準CRC32算法從類型名計算出一個整數作為類ID也許是個不錯的想法[3]。

　　程序清單

// URtti.h
#ifndef __URTTI_H__
#define __URTTI_H__

class UObject;

struct TypeInfo
{
char* className;
int type_id;
TypeInfo* pBaseClass;
operator== (const TypeInfo& info){
return this==&info;
}
operator!= (const TypeInfo& info){
return this!=&info;
}
};

inline std::ostream& operator<< (std::ostream& os,TypeInfo& info)
{
return (os<< "[" << &info << "]" << "\t"
<< info.type_id << ":"
<< info.className << ":"
<< info.pBaseClass << std::endl);
}

extern int TypeInfoOrder;

struct InitTypeInfo
{
InitTypeInfo(/*TypeInfo* base,*/TypeInfo* info)
{
info->type_id=TypeInfoOrder++;
}
};

#define TYPEINFO_OF_CLASS(class_name) (class_name::GetTypeInfoClass())
#define TYPEINFO_OF_OBJ(obj_name) (obj_name.GetTypeInfo())
#define TYPEINFO_OF_PTR(ptr_name) (ptr_name->GetTypeInfo())

#define DECLARE_TYPEINFO(class_name) public: virtual int GetTypeID(){return TYPEINFO_MEMBER(class_name).type_id;} virtual char* GetTypeName(){return TYPEINFO_MEMBER(class_name).className;} virtual TypeInfo& GetTypeInfo(){return TYPEINFO_MEMBER(class_name);} static TypeInfo& GetTypeInfoClass(){return TYPEINFO_MEMBER(class_name);} private: static TypeInfo TYPEINFO_MEMBER(class_name); static InitTypeInfo initClassInfo;
#define IMPLEMENT_TYPEINFO(class_name,base_name) TypeInfo class_name::TYPEINFO_MEMBER(class_name)= {#class_name,0,&(base_name::GetTypeInfoClass())}; InitTypeInfo class_name::initClassInfo(&(class_name::TYPEINFO_MEMBER(class_name)));

#define DYNAMIC_CAST(object_ptr,class_name) safe_cast(object_ptr,TYPEINFO_OF_CLASS(class_name))

#define TYPEINFO_MEMBER(class_name) rttiTypeInfo

class UObject
{
public:
bool IsKindOf(TypeInfo& cls);
public:
virtual int GetTypeID(){return TYPEINFO_MEMBER(UObject).type_id;}
virtual char* GetTypeName(){return TYPEINFO_MEMBER(UObject).className;}
virtual TypeInfo& GetTypeInfo(){return TYPEINFO_MEMBER(UObject);}
static TypeInfo& GetTypeInfoClass(){return TYPEINFO_MEMBER(UObject);}
private:
static TypeInfo TYPEINFO_MEMBER(UObject);
static InitTypeInfo initClassInfo;
};

template
inline T* safe_cast(UObject* ptr,TypeInfo& cls)
{
return (ptr->IsKindOf(cls)?(T*)ptr:NULL);
}
#endif
// URtti.cpp
＃i nclude "urtti.h"

extern int TypeInfoOrder=0;

TypeInfo UObject::TYPEINFO_MEMBER(UObject)={"UObject",0,NULL};
InitTypeInfo UObject::initClassInfo(&(UObject::TYPEINFO_MEMBER(UObject)));

bool UObject::IsKindOf(TypeInfo& cls)
{
TypeInfo* p=&(this->GetTypeInfo());
while(p!=NULL){
if(p->type_id==cls.type_id)
return true;
p=p->pBaseClass;
}
return false;
}
// mail.cpp
＃i nclude
＃i nclude "urtti.h"
using namespace std;

class UView:public UObject
{
DECLARE_TYPEINFO(UView)
};
IMPLEMENT_TYPEINFO(UView,UObject)

class UGraph:public UObject
{
DECLARE_TYPEINFO(UGraph)
};
IMPLEMENT_TYPEINFO(UGraph,UObject)

void main()
{
UObject* po=new UObject;
UView* pv=new UView;
UObject* pg=new UGraph;
if(DYNAMIC_CAST(po,UView))
cout << "po => UView succeed" << std::endl;
else
cout << "po => UView failed" << std::endl;
if(DYNAMIC_CAST(pv,UView))
cout << "pv => UView succeed" << std::endl;
else
cout << "pv => UView failed" << std::endl;
if(DYNAMIC_CAST(po,UGraph))
cout << "po => UGraph succeed" << std::endl;
else
cout << "po => UGraph failed" << std::endl;
if(DYNAMIC_CAST(pg,UGraph))
cout << "pg => UGraph succeed" << std::endl;
else
cout << "pg => UGraph failed" << std::endl;
}
　　實現結果

　　本文實現了如下幾個宏來支持RTTI，它們的使用方法都可以在上面的代碼中找到：
　　

宏函數 功能及參數說明
DECLARE_TYPEINFO(class_name)  為類添加RTTI功能放在類聲明的起始位置
IMPLEMENT_TYPEINFO(class_name,base) 同上，放在類定義任何位置
TYPEINFO_OF_CLASS(class_name) 相當于typeid(類名)
TYPEINFO_OF_OBJ(obj_name) 相當于typeid(對象)
TYPEINFO_OF_PTR(ptr_name) 相當于typeid(指針)
DYNAMIC_CAST(object_ptr,class_name) 相當于dynamic_castobject_ptr
性能測試

　　測試代碼：

　　這里使用相同次數的DYNAMIC_CAST和dynamic_cast進行對比測試，在VC6.0下編譯運行，使用默認的Release編譯配置選項。為了避免編譯器優化導致的不公平測試結果，我在循環中加入了無意義的計數操作。

void main()
{
UObject* po=new UObject;
UView* pv=new UView;
UObject* pg=new UGraph;
int a,b,c,d;
a=b=c=d=0;
const int times=30000000;
cerr << "時間測試輸出：" << endl;
cerr << "start my DYNAMIC_CAST at: " << time(NULL) << endl;
for(int i=0;i if(DYNAMIC_CAST(po,UView)) a++; else a--;
if(DYNAMIC_CAST(pv,UView)) b++; else b--;
if(DYNAMIC_CAST(po,UGraph)) c++; else c--;
if(DYNAMIC_CAST(pg,UGraph)) d++; else d--;
}
cerr << "end my DYNAMIC_CAST at: " << time(NULL) << endl;
cerr << "start c++ dynamic_cast at: " << time(NULL) << endl;
for(i=0;i if(dynamic_cast(po)) a++; else a--;
if(dynamic_cast(pv)) b++; else b--;
if(dynamic_cast(po)) c++; else c--;
if(dynamic_cast(pg)) d++; else d--;
}
cerr << "end c++ dynamic_cast at: " << time(NULL) << endl;
cerr << a << b << c << d << endl;
}
　　運行結果：

start my DYNAMIC_CAST at: 1021512140
end my DYNAMIC_CAST at: 1021512145
start c++ dynamic_cast at: 1021512145
end c++ dynamic_cast at: 1021512160
　　這是上述條件下的測試輸出，我們可以看到，本文實現的這個精簡RTTI方案運行DYNAMIC_CAST的時間開銷只有dynamic_cast的1/3。為了得到更全面的數據，還進行了DEBUG編譯配置選項下的測試。

　　輸出：

start my DYNAMIC_CAST at: 1021512041
end my DYNAMIC_CAST at: 1021512044
start c++ dynamic_cast at: 1021512044
end c++ dynamic_cast at: 1021512059
　　這種情況下DYNAMIC_CAST運行速度要比dynamic_cast慢一倍左右。如果在Release編譯配置選項下將UObject::IsKindOf方法改成如下inline函數，我們將得到更讓人興奮的結果（DYNAMIC_CAST運行時間只有dynamic_cast的1/5）。

inline bool UObject::IsKindOf(TypeInfo& cls)
{
for(TypeInfo* p=&(this->GetTypeInfo());p!=NULL;p=p->pBaseClass)
if(p==&cls) return true;
return false;
}
　　輸出：

start my DYNAMIC_CAST at: 1021512041
end my DYNAMIC_CAST at: 1021512044
start c++ dynamic_cast at: 1021512044
end c++ dynamic_cast at: 1021512059
　　結論：

　　由本文的實踐可以得出結論，自己動手編碼實現RTTI是簡單可行的。這樣的實現可以在編譯器優秀的代碼優化中表現出比dynamic_cast更好的性能，而且沒有帶來過多的存儲開銷。本文的RTTI以性能為主要設計目標，在實現上一定程度上受到了MFC的影響。適于嵌入式環境。