C++中RTTI机制

最新推荐文章于 2024-02-05 21:49:04 发布

鸿鹄之志9344

最新推荐文章于 2024-02-05 21:49:04 发布

阅读量314

点赞数 1

分类专栏： C++

C++ 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

学习：

http://blog.csdn.net/mannhello/article/details/5217954

http://www.cnblogs.com/lzjsky/archive/2010/11/23/1885771.html

http://www.yesky.com/20020810/1624534.shtml

关于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<<endl; 与上一行类似
cout<TypeOfClass()==UDialogClass<<endl;
cout<TypeOfClass()==UObjectClass<<endl;
cout<TypeOfClass()==UDialogClass<<endl;< td="">

　　输出：

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继承。

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。

2、添加rttiTypeInfo变量。

　　3、在类外正确初始化rttiTypeInfo静态成员。

　　4、覆盖GetTypeID、GetTypeName、GetTypeInfo、GetTypeInfoClass四个成员函数。

　　如下所示：

　　有了前三步，这样我们就可以得到一个不算太复杂的链表――这是一棵类型信息构成的"树"，与数据结构中的树的唯一差别就是其指针方向相反。

这样，从任何一个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：

template
inline T* safe_cast(UObject* ptr,TypeInfo& cls)
{
return (ptr->IsKindOf(cls)?(T*)ptr:NULL);
}

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));

template
inline T* safe_cast(UObject* ptr,TypeInfo& cls)
{
return (ptr->IsKindOf(cls)?(T*)ptr:NULL);
}

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成员的构造函数InitTypeInfo::InitTypeInfo(TypeInfo* info)，而正是这个函数替我们产生并设置了类ID。InitTypeInfo的构造函数还可以替我们做其他一些有用的初始化工作，比如将所有的TypeInfo信息登录到一个表格里，让我们可以很方便的遍历它。
　　但实践与查阅资料让我们发现，由于C++中对静态成员初始化的顺序没有明确的规定，所以这样的方式产生出来的类ID并非完全静态，换一个编译器编译执行产生的结果可能完全不同。

　　还有一个可以考虑的方案是采用某种无冲突HASH算法，将类名转换成为一个唯一整数。使用标准CRC32算法从类型名计算出一个整数作为类ID也许是个不错的想法[3]。

　　程序清单

template
inline T* safe_cast(UObject* ptr,TypeInfo& cls)
{
return (ptr->IsKindOf(cls)?(T*)ptr:NULL);
}

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));

template
inline T* safe_cast(UObject* ptr,TypeInfo& cls)
{
return (ptr->IsKindOf(cls)?(T*)ptr:NULL);
}

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));

template
inline T* safe_cast(UObject* ptr,TypeInfo& cls)
{
return (ptr->IsKindOf(cls)?(T*)ptr:NULL);
}

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成员的构造函数InitTypeInfo::InitTypeInfo(TypeInfo* info)，而正是这个函数替我们产生并设置了类ID。InitTypeInfo的构造函数还可以替我们做其他一些有用的初始化工作，比如将所有的TypeInfo信息登录到一个表格里，让我们可以很方便的遍历它。
#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

template
inline T* safe_cast(UObject* ptr,TypeInfo& cls)
{
return (ptr->IsKindOf(cls)?(T*)ptr:NULL);
}

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成员的构造函数InitTypeInfo::InitTypeInfo(TypeInfo* info)，而正是这个函数替我们产生并设置了类ID。InitTypeInfo的构造函数还可以替我们做其他一些有用的初始化工作，比如将所有的TypeInfo信息登录到一个表格里，让我们可以很方便的遍历它。
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
#include "urtti.h"

template
inline T* safe_cast(UObject* ptr,TypeInfo& cls)
{
return (ptr->IsKindOf(cls)?(T*)ptr:NULL);
}

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));

template
inline T* safe_cast(UObject* ptr,TypeInfo& cls)
{
return (ptr->IsKindOf(cls)?(T*)ptr:NULL);
}

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成员的构造函数InitTypeInfo::InitTypeInfo(TypeInfo* info)，而正是这个函数替我们产生并设置了类ID。InitTypeInfo的构造函数还可以替我们做其他一些有用的初始化工作，比如将所有的TypeInfo信息登录到一个表格里，让我们可以很方便的遍历它。
class UView:public UObject
{
DECLARE_TYPEINFO(UView)
};
IMPLEMENT_TYPEINFO(UView,UObject)

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

template
inline T* safe_cast(UObject* ptr,TypeInfo& cls)
{
return (ptr->IsKindOf(cls)?(T*)ptr:NULL);
}

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成员的构造函数InitTypeInfo::InitTypeInfo(TypeInfo* info)，而正是这个函数替我们产生并设置了类ID。InitTypeInfo的构造函数还可以替我们做其他一些有用的初始化工作，比如将所有的TypeInfo信息登录到一个表格里，让我们可以很方便的遍历它。
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;
}

template
inline T* safe_cast(UObject* ptr,TypeInfo& cls)
{
return (ptr->IsKindOf(cls)?(T*)ptr:NULL);
}

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));

宏函数	功能及参数说明
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

template
inline T* safe_cast(UObject* ptr,TypeInfo& cls)
{
return (ptr->IsKindOf(cls)?(T*)ptr:NULL);
}

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成员的构造函数InitTypeInfo::InitTypeInfo(TypeInfo* info)，而正是这个函数替我们产生并设置了类ID。InitTypeInfo的构造函数还可以替我们做其他一些有用的初始化工作，比如将所有的TypeInfo信息登录到一个表格里，让我们可以很方便的遍历它。
　性能测试

　　测试代码：

　　这里使用相同次数的DYNAMIC_CAST和dynamic_cast进行对比测试，在VC6.0下编译运行，使用默认的Release编译配置选项。为了避免编译器优化导致的不公平测试结果，我在循环中加入了无意义的计数操作。

template
inline T* safe_cast(UObject* ptr,TypeInfo& cls)
{
return (ptr->IsKindOf(cls)?(T*)ptr:NULL);
}

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成员的构造函数InitTypeInfo::InitTypeInfo(TypeInfo* info)，而正是这个函数替我们产生并设置了类ID。InitTypeInfo的构造函数还可以替我们做其他一些有用的初始化工作，比如将所有的TypeInfo信息登录到一个表格里，让我们可以很方便的遍历它。
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<times;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<times;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;
}

template
inline T* safe_cast(UObject* ptr,TypeInfo& cls)
{
return (ptr->IsKindOf(cls)?(T*)ptr:NULL);
}

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));

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编译配置选项下的测试。

　　输出：

template
inline T* safe_cast(UObject* ptr,TypeInfo& cls)
{
return (ptr->IsKindOf(cls)?(T*)ptr:NULL);
}

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));

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;
}

　　输出：

template
inline T* safe_cast(UObject* ptr,TypeInfo& cls)
{
return (ptr->IsKindOf(cls)?(T*)ptr:NULL);
}

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));

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的影响。适于嵌入式环境。

template
inline T* safe_cast(UObject* ptr,TypeInfo& cls)
{
return (ptr->IsKindOf(cls)?(T*)ptr:NULL);
}

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));

鸿鹄之志9344

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
C++中RTTI机制

学习：http://blog.csdn.net/mannhello/article/details/5217954http://www.cnblogs.com/lzjsky/archive/2010/11/23/1885771.htmlhttp://www.yesky.com/20020810/1624534.shtml关于C++中RTTI的编码实现摘要：
复制链接

扫一扫