C++对象模型之RTTI的实现原理是什么

本文介绍了“RTTI在C对象模型中的实现原理是什么”的知识。很多人在实际案例的操作中会遇到这样的困难。让边肖带领你学习如何处理这些情况。希望大家认真阅读，学点东西！

RTTI是运行时类型标识的缩写，意思是运行时类型标识。c引入了这种机制，使程序能够在运行时获得基类的指针或引用所指向的对象的实际类型。但是现在RTTI的类型识别不仅限于此，它还可以识别基本类型(int、pointer等)的所有变量对应的类型。)通过typeid运算符。

通过以下两种操作为RTTI提供服务：

Typeid运算符，返回其表达式或类型名称的实际类型。

Dynamic_cast运算符，它将基类的指针或引用安全地转换为派生类类型的指针或引用。

下面将详细描述这两个操作的实现。

注意所有测试代码的测试环境都是32位的Ubuntu 14.04 g 4.8.2，不同环境下测试的结果可能会有所不同。

1、typeid运算符

Typeid运算符，后跟类型名或表达式，返回std:tpeinf类型对象的常量引用。Type_info是std中的一个类，用于记录与类型相关的信息。Type_info的大致定义如下：

class type _ info { public : virtual ~ type _ info()；boolooperator==(const type _ info)const；扬声器！=(consttype_info)常量；bool before(const type _ info)const；const char * name()const；private : type _ info(const type _ info)；type _ info operator=(const type _ info)；//data members }；至于数据成员部分，不同的编译器会有所不同，但必须提供的最小信息量是类的真实名称，type_info对象之间的一些排序算法(由before()成员函数提供)，以及用于表示类的显式类型和类的任何子类型的一些形式的描述符。

从上面的定义可以看出，type_info为两个对象提供了相等比较操作，但是用户不能自己定义type_info的对象，只能通过typeid运算符返回一个对象的const引用来使用type_info的对象。因为它只声明一个构造函数(复制构造函数)并且是私有的，所以编译器不会合成任何构造函数，赋值运算符也是私有的。这两个操作完全禁止用户定义和复制type_info对象，用户只能通过对type_info对象的指针或引用来使用类。

我们来谈谈typeid对静态类型表达式和动态类型表达式的处理和实现。

1)typeid识别静态类型

当typeid中的操作数是下列情况之一时，typeid运算符指示操作数的静态类型，即编译时的类型。

类型名

基本类型的变量。

一个具体的物体。

指针对不包含虚函数的类对象的取消引用。

>

一个指向不含有virtual函数的类对象的引用

静态类型在程序的运行过程中并不会改变，所以并不需要在程序运行时计算类型，在编译时就能根据操作数的静态类型，推导出其类型信息。例如如下的代码片断，typeid中的操作数均为静态类型：

class X  {  ...... // 具有virtual函数 };  class XX : public X  { ...... // 具有virtual函数};  class Y  { ...... // 没有virtual函数};    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函数     cout << typeid(*py).name() << endl;     return 0; }

2)typeid识别多态类型

当typeid中的操作数是如下情况之一时，typeid运算符需要在程序运行时计算类型，因为其其操作数的类型在编译时期是不能被确定的。

• 一个指向不含有virtual函数的类对象的指针的解引用

• 一个指向不含有virtual函数的类对象的引用

多态的类型是可以在运行过程中被改变的，例如，一个基类的指针，在程序运行的过程中，它可以指向一个基类对象，也可以指向该基类的派生类的对象，而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; }

其输出如下：

从输出的结果可以看出，无论printTypeInfo函数中指针px指向的对象是基类X的对象，还是指向派生类XX的对象，typeid运行返回的px的类型信息都是相同的，因为px为一个静态类型，其类型名均为PX1X。但是typeid运算符却能正确地计算出了px指向的对象的实际类型。(注：由于C++为了保证每一个类在程序中都有一个独一无二的类名，所以会对类名通过一定的规则进行改写，所以在这里显示的类名跟我们定义的有一些不一样，如类XX的类名，被改写成了2XX。)

那么问题来了，typeid是如何计算这个类型信息的呢?下面将重点说明这个问题。

多态类型是通过在类中声明一个或多个virtual函数来区分的。因为在C++中，一个具备多态性质的类，正是内含直接声明或继承而来的virtual函数。多态类的对象的类型信息保存在虚函数表的索引的-1的项中，该项是一个type_info对象的地址，该type_info对象保存着该对象对应的类型信息，每个类都对应着一个type_info对象。下面就对这一说法进行验证。

使用如以的代码，对上述的类X和类XX的对象的内存布局进行测试：

typedef void (*FuncPtr)(); int main() {     XX xx;     FuncPtr func;     char *p = (char*)&xx;     // 获得虚函数表的地址     int **vtbl = (int**)*(int**)p;     // 输出虚函数表的地址，即vptr的值     cout << vtbl << endl;     // 获得type_info对象的指针，并调用其name成员函数     cout << "\t[-1]: " << (vtbl[-1]) << " -> "         << ((type_info*)(vtbl[-1]))->name() << endl;     // 调用第一个virtual函数     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的对象的内存布局进行测试，其输出结果如下：

从运行结果可以看到，利用虚函数表的-1的项的地址转换成一个type_info的指针类型，并调用name成员函数的输出为2XX，其输出与前面的测试代码中利用typeid的输出一致。从而可以知道，关于多态类型的计算是通过基类指针或引用指向的对象(子对象)的虚函数表获得的。

从运行的结果可以知道，类XX的对象的内存布局如下：

对于以下的代码片断：

typeid(*px).name()

可能被转换成如下的C++伪代码，用于计算实际对象的类型：

(*(type_info*)px->vptr[-1]).name();

在多重继承和虚拟继承的情况下，一个类有n(n>1)个虚函数表，该类的对象也有n个vptr，分别指向这些虚函数表，但是一个类的所有的虚函数表的索引为-1的项的值(type_info对象的地址)都是相等的，即它们都指向同一个type_info对象，这样就实现了无论使用了哪一个基类的指针或引用指向其派生类的对象，都能通过相应的虚函数表获取到相同的type_info对象，从而得到相同的类型信息。

3)typeid的识别错误的情况

从第2)节可以看到，typeid对于多态类型是通过虚函数表来计算的，若一个基类的指针指向了一个派生类，而该派生类并不存在virtual函数会出现什么情况呢?

例如，把第2)节中的X和XX类中的virtual函数全部去掉，改成以下的代码：

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

其输出如下：

从输出的结果可以看到，对于注释1的函数调用，虽然函数中基类(X)的指针px指向一个派生类对象(XX类的对象xx)，但是typeid却并不没有像第2)节那样能正确地通过指针px计算出其所指对象的实际类型。

其原因在于类XX和类X都没有一个virtual函数，所以类XX和类X并不表现出多态类的性质。所以对类的指针的解引用符合第1)节中所说的静态类型，所以其类型信息是在编译时就已经确定的，并不需要在程序运行的过程中运行计算，所以其输出的类型均为1X而没有输出1XX。更进一步说，是因为类X和类XX都不存在virtual函数，所以类X和XX都不存在虚函数表，所以也就没有空间存储跟类X和XX类型有关的type_info对象的地址。

然而在C++中即使一个类不具有多态的性质，仍然允许把一个派生类的指针赋值给一个基类的指针，所以这个错误比较隐晦。

2、dynamic_cast运算符

把一个基类类型的指针或引用转换至继承架构的末端某一个派生类类型的指针或引用被称为向下转型(downcast)。dynamic_cast运算符的作用是安全而有效地进行向下转型。

把一个派生类的指针或引用转换成其基类的指针或引用总是安全的，因为通过分析对象的内存布局可以知道，派生类的对象中必然存在基类的子对象，所以通过基类的指针或引用对派生类对象进行的所有基类的操作都是合法和安全的。而向下转型有潜在的危险性，因为基类的指针可以指向基类对象或其任何派生类的对象，而该对象并不一定是向下转型的类型的对象。所以向下转型遏制了类型系统的作用，转换后对指针或引用的使用可能会引发错误的解释或腐蚀程序内存等错误。

例如对于以下的类定义：

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

使用如下的测试代码，其中的类型转换均为向下转型：

int main(){ X x; XX xx; YX yx; X *px = &xx; cout << px << endl; XX *pxx = dynamic_cast<XX*>(px); // 转换1 cout << pxx << endl; YX *pyx = dynamic_cast<YX*>(px); // 转换2 cout << pyx << endl; pyx = (YX*)px; // 转换3 cout << pyx << endl; pyx = static_cast<YX*>(px); // 转换4 cout << pyx << endl; return 0;}

其运行结果如下：

运行结果分析

px是一个基类(X)的指针，但是它指向了派生类XX的一个对象。在转换1中，转换成功，因为px指向的对象确实为XX的对象。在转换2中，转换失败，因为px指向的对象并不是一个YX对象，此时dymanic_cast返回NULL。转换3为C风格的类型转换而转换4使用的是C++中的静态类型转换，它们均能成功转换，但是这个对象实际上并不是一个YX的对象，所以在转换3和转换4中，若继续通过指针使用该对象必然会导致错误，所以这个转换是不安全的。

从上述的结果可以看出在向下转型中，只有dynamic_case才能实现安全的向下转型。那么dynamic_case是如何实现的呢?有了上面typeid和虚函数表的知识后，这个问题并不难解释了，以转换1为例。

• 计算指针或引用变量所指的对象的虚函数表的type_info信息，如下：

*(type_info*)px->vptr[-1]

• 静态推导向下转型的目标类型的type_info信息，即获取类XX的type_info信息

• 比较1)和2)中获取到的type_info信息，若2)中的类型信息与1)中的类型信息相等或是其基类类型，则返回相应的对象或子对象的地址，否则返回NULL。

引用的情况与指针稍有不同，失败时并不是返回NULL，而是抛出一个bad_cast异常，因为引用不能参考NULL。

“C++对象模型之RTTI的实现原理是什么”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注网站，小编将为大家输出更多高质量的实用文章！