从RTTI谈C++的向下转型

川长思鸟来 2022-08-09 01:55 156阅读 0赞

# 1.什么是RTTI？ #

RTTI 是“Runtime Type Information”的缩写，意思是：运行时类型信息。它提供了运行时确定对象类型的方法。允许“用指向基类的指针或引用来操纵对象”的程序能够获取到“这些指针或引用所指对象”的实际派生类型。在 c++中，为了支持 RTTI 提供了两个操作符 ：   
    1 dynamic\_cast 操作符：它允许在运行时刻进行类型转换，从而使程序能够在一个类层次结构中安全地转换类型（**安全的向下转型**）。**把基类指针转换成派生类指针，或把指向基类的左值转换成派生类的引用。**当然只有在保证转换能够成功的情况下才可以；    
    2 typeid操作符：它指出指针或引用指向的对象的实际派生类型。

但是，对于要获得的派生类类型的信息，dynamic\_cast 和 typeid操作符的操作数的类型必须是带有一个或多个虚拟函数的类类型，即对于带有虚拟函数的类而言，RTTI 操作符是运行时刻的事件，而对于其他类而言，它只是编译时刻的事件。

# 2. RTTI如何实现 #

C++的RTTI是最简单的，只能获得类名和相关的继承信息；而VB、Delphi、Java等确复杂得多，甚至于支持属性名、方法名、事件名等。

![28541347_1399996741tf7l.jpg][]

如图，C++使用type\_info类的对象保存每个对象的相关信息如对象名称、对象类型等。而所谓RTTI就是在执行期取得对象的type\_info。所以C++采用了和虚函数同样的办法，使用vtable（通常为第一个slot）保存需要执行期获得type\_info的对象的type\_info对象地址。那么由pt指向的class object的type\_info可在执行期通过如下方式获得：

(type\_info)\*(type\_info\*)(pt->vptr\[0\]);

通过上述实现分析我们也可以知道，**C++的RTTI只能用于那些展现“多态”（内含虚函数）的类型有效。因为只有这样的类才有vtable。**

# 3. 向下转型 #

将一个Base class对象的指针转为Derived class对象的指针或将Base class的左值转为Derived class的引用称为向下转型。

**注：不能讲Base class的对象转为Derived class的对象（除非定义相应转换操作符）。**如下语句是错误的：

Base bobj;

Derived dobj=static\_cast(bobj) ;//error,

Derived dobj=(Derived)(bobj) ;//error

但如下语句是正确的：

Derived dobj;

Base bobj=(Base)dobj;//正确，造成对象切割

Base bobj=static\_cast(dobj);//正确，造成对象切割

向下转型示例：

(1) 基类指针转为子类指针

Base bobj;

Base \*pb=&bobj;

Derived \*pd=(Derived\*)pb;//方式一

Derived \*pd=static\_cast(pb);//方式二

Derived \*pd=dynamic\_cast(pb);//方式三，只有Base class中有虚函数才能使用，否则编译错误（Derived class中有虚函数也不行）

(2) 基类左值转子类引用

Base bobj;

Derived dobj;

Derived &dref=(Derived&)(bobj);//方式一

Derived &dref=static\_cast(bobj);//方式二

Derived &dref=dynamic\_cast(bobj);//方式三，只有Base class中有虚函数才能使用，否则编译错误（Derived class中有虚函数也不行）

(3) 基类左值转子类引用

Derived dobj;

Base& bref=dobj;

Derived &dref=(Derived&)(bref);

Derived &dref=static\_cast(bref);

Derived &dref=dynamic\_cast(bref);

**向下转型的隐患**

向下转型有着潜在的危险，因为当基类指针指向的是基类对象，而将基类指针转为子类指针时，如果通过转换后的子类指针访问子类的专有成员，就会造成内存错误，因为实际指向的是基类对象，而基类对象中不存在这些成员。（引用转换类似）

# 4. 安全的向下转型——dynamic\_cast<>() #

所谓“安全的向下转型”即只有当Base class的指针确实指向Derived class对象时才能将其转为Derived class的指针。但是我们知道

**Base ****class****的指针所指向的对象类型****在执行期是可以改变的**（指向Base class对象或Derived class对象），所以要想保证向下转型的安全性，就必须在**执行期**对Base class的指针有所查询，看看它所指向对象的真正类型。

dynamic\_cast运算符可以在执行期确定指针指向的真正类型（前提是Base class中要有虚函数）。

**当对Base class的指针向下转型时，如果向下转型时是安全的（也就是Base type pointer指向一个Derived class object），则这个运算符传回相应的Derived class指针，如果向下转型是不安全的，则这个运算符传回0.**

**当对Base class的引用向下转型时，如果向下转型时是安全的（也就是Base type reference引用一个Derived class object），则这个运算符传回相应的Derived class引用，否则抛出一个bad\_cast exception，而不是返回0. 不返回0的原因是，若将一个引用设为0，会使一个临时性对象产生出来，该临时性对象的初值为0，这个引用被设置为这个对象的别名。**

**dynamic\_cast的成本**

由于要在执行期获取对象类型信息（type\_info），类似虚函数调用：

(type\_info)\*(type\_info\*)(pt->vptr\[0\]);

当使用dynamic\_cast进行Base class指针向下转型时，dynamic\_cast会采用这种方法获取Base class指针和Derived class指针指向对象的type\_info对象，并将两个type\_info对象中的类型描述器交给一个runtime library函数，比较之后告诉我们是否吻合。这显然比static\_cast的开销昂贵的多，但是安全的多。

# 5. Typeid运算符 #

**Typeid运算符传回一个type\_info对象的const引用。**

1. typeid操作符必须与**表达式或类型名**一起使用。例如，内置类型的表达式和常量可以被用作 typeid的操作数。

(1) 当操作数不是类类型时，typeid操作符会指出操作数的类型 ，**此时type\_info对象的引用是在编译期获得，**如：   
        int iobj;   
        cout << typeid( iobj ).name() << endl; // 打印: int   
        cout << typeid( 8.16 ).name() << endl; // 打印: double

(2) 当typeid操作符的操作数是类类型，但不是带有虚拟函数的类类型时，typeid操作符会指出操作数的类型，而不是底层对象的类型，**此时type\_info对象的引用是在编译期获得**，如：

class Base \{ /\* 没有虚拟函数 \*/ \};   
       class Derived : public Base \{  /\* 没有虚拟函数 \*/ \};   
        Derived dobj;   
       Base \*pb = &dobj;   
       cout << typeid( \*pb ).name() << endl; // 打印: class Base

由于typeid操作符的操作数是 Base 类型的，即表达式\*pb 的类型。而 Base 不是一个带有虚拟函数的类类型，所以typeid的结果是Base。尽管 pb 指向的底层对象的类型是 Derived。

(3) 当typeid操作符的操作数是类类型，且该类是带有虚拟函数的类类型时，typeid操作符会指出实际底层对象的类型，**此时type\_info对象的引用是在执行期获得**，如：

class Base \{  /\* 有虚拟函数 \*/ \};

class Derived : public Base \{\};

Derived dobj;

Base \*pb = &dobj;

cout << typeid( \*pb ).name() << endl; // 打印: class Derived

2. 可以对 typeid的结果进行比较。例如    
     \#include    
     employee \*pe = new manager;   
     employee& re = \*pe;   
   
     if ( typeid( pe ) == typeid( employee\* ) ) // true   
     if ( typeid( pe ) == typeid( manager\* ) ) // false   
     if ( typeid( pe ) == typeid( employee ) ) // false   
     if ( typeid( pe ) == typeid( manager ) ) // false   
     if语句的条件子句比较“在一个表达式上应用typeid操作符的结果”和“用在类型名操作数上的typeid操作符的结果”。注意比较    
     typeid( pe ) == typeid( employee\* )  的结果为true。

这是因为操作数pe 是一个指针，而不是一个类类型。为了要获取到派生类类型 ，typeid的操作数必须是一个类类型（带有虚拟函数）。表达式 typeid(pe)指出pe 的类型，即指向employee 的指针，它与表达式 typeid(employee\*)相等。而其他比较的结果都是false。    
    当表达式\*pe 被用在typeid上时，结果指出pe 指向的底层对象的类型    
    typeid( \*pe ) == typeid( manager ) // true   
    typeid( \*pe ) == typeid( employee ) // false   
      在这两个比较中，因为\*pe 是一个类类型的表达式，该类带有虚拟函数，所以typeid的结果指出操作数所指的底层对象的类型，即manager 。   
   typeid操作符也可以被用在引用上。例如    
   typeid( re ) == typeid( manager ) // true   
   typeid( re ) == typeid( employee ) // false   
   typeid( &re ) == typeid( employee\* ) // true   
   typeid( &re ) == typeid( manager\* ) // false

在前两个比较中，操作数re 是带有虚拟函数的类类型。因此 typeid操作数的结果指出 re指向的底层对象的类型。在后两个比较中，操作数&re 是一个类型指针，因此 typeid操作符的结果指出操作数的类型，即 employee\* 。

http://blog.chinaunix.net/uid-26430381-id-4253503.html

http://www.cppblog.com/mzty/archive/2006/01/05/2446.html

[28541347_1399996741tf7l.jpg]: http://blog.chinaunix.net/attachment/201405/13/28541347_1399996741tf7l.jpg