浅议 Dynamic_cast 和 RTTI

痛定思痛。 2023-01-15 13:25 205阅读 0赞

[浅议 Dynamic\_cast 和 RTTI][Dynamic_cast _ RTTI]

写这篇博文的目的是，记录学习过程。

对于问题要较真，在解决这个问题中会学到很多，远远超过自己期望，锻炼思维，享受这个过程。

# **问题： Static\_cast 与 Dynamic\_cast的区别** #

来自书本上的解释：

**  用 static\_cast<type-id > ( expression )  **

1. static\_cast(expression) The static\_cast<>() is used to cast between the integer types. 'e.g.' char->long, int->short etc.

用来数值之间的转化。

2.  可以在相关指针之间转换，指针在void \* 之间转换，还可以在基类和派生类之间转换。 这些转换是在编译的时候就确定下来转换（无非就是根据继承关系，偏移指针而已），但是这需要自己保证安全。

比如

![复制代码][copycode.gif]

#include 
        
         <
        
         iostream
        
         >
        
         
        
         using
        
         
        
         namespace
        
         std; 
        
         class
        
         Base { 
        
         public
        
         : 
        
         virtual
        
         
        
         void
        
         f() {cout
        
         <<
        
         "
        
         Base::f()
        
         "
        
         <<
        
         endl;} }; 
        
         class
        
         Derive: 
        
         public
        
         Base { 
        
         public
        
         : 
        
         virtual
        
         
        
         void
        
         f() {cout
        
         <<
        
         "
        
         Derive::f()
        
         "
        
         <<
        
         endl;} 
        
         virtual
        
         
        
         void
        
         f2() {cout
        
         <<
        
         "
        
         Derive::f1()
        
         "
        
         <<
        
         endl;} }; 
        
         int
        
         main() { Base 
        
         *
        
         pbase1 
        
         =
        
         
        
         new
        
         Derive(); Derive
        
         *
        
         pderive1 
        
         =
        
         static_cast
        
         <
        
         Derive 
        
         *>
        
         (pbase1); pderive1
        
         ->
        
         f(); 
        
         //
        
         Derive::f()
        
         
        
         Base
        
         *
        
         pbase2 
        
         =
        
         
        
         new
        
         Base(); Derive 
        
         *
        
         pderive2 
        
         =
        
         static_cast
        
         <
        
         Derive 
        
         *>
        
         (pbase2); pderive2
        
         ->
        
         f(); 
        
         //
        
         Base::f()
        
         
        
         pderive2
        
         ->
        
         f2(); 
        
         //
        
         throw exception "Access violation reading"
        
         
        
         delete pbase1; delete pbase2; }

![复制代码][copycode.gif]

虽然 由 pbase2 转化到 pderive2 ，编译器编译正确。 但是当调用 pderive2\->f(); 应该不是希望的； 调用pderive2\->f2() 因为基类本身就没有这个函数，说以运行时出错，抛出异常。

所以说static\_cast 是编译时确定下来，需要自己确保转换类型安全，否则运行时会抛出异常.

注意static\_cast 不能直接在没有继承关系的对象指针之间进行转换。在Com 里面实现不同接口的同个对象，其也不能再接口之间转换（更何况是动态的），所以COM提供一个query 借口。

**用法：dynamic\_cast < type-id > ( expression)**

是专门用于具有继承关系的类之间转换的，尤其是向下类型转换，是安全的。

![复制代码][copycode.gif]

#include 
        
         <
        
         iostream
        
         >
        
         
        
         using
        
         
        
         namespace
        
         std; 
        
         class
        
         Base { 
        
         public
        
         : 
        
         virtual
        
         
        
         void
        
         f() {cout
        
         <<
        
         "
        
         Base::f()
        
         "
        
         <<
        
         endl;} }; 
        
         class
        
         Derive: 
        
         public
        
         Base { 
        
         public
        
         : 
        
         virtual
        
         
        
         void
        
         f() {cout
        
         <<
        
         "
        
         Derive::f()
        
         "
        
         <<
        
         endl;} 
        
         virtual
        
         
        
         void
        
         f2() {cout
        
         <<
        
         "
        
         Derive::f1()
        
         "
        
         <<
        
         endl;} }; 
        
         int
        
         main() { Base 
        
         *
        
         pbase1 
        
         =
        
         
        
         new
        
         Derive(); Derive
        
         *
        
         pderive1 
        
         =
        
         dynamic_cast
        
         <
        
         Derive 
        
         *>
        
         (pbase1); 
        
         //
        
         down-cast
        
         
        
         pderive1
        
         ->
        
         f(); 
        
         //
        
         Derive::f()
        
         
        
         Base
        
         *
        
         pbase2 
        
         =
        
         
        
         new
        
         Base(); Derive 
        
         *
        
         pderive2 
        
         =
        
         dynamic_cast
        
         <
        
         Derive 
        
         *>
        
         (pbase2); 
        
         //
        
         up-cast
        
         
        
         
        
         if
        
         ( pderive2) 
        
         //
        
         NULL
        
         
        
         { pderive2
        
         ->
        
         f(); pderive2
        
         ->
        
         f2(); } delete pbase1; delete pbase2; }

![复制代码][copycode.gif]

dynamic\_cast 如何保证转换是安全的？ 如何知道具体该类的具体类型 以及 继承关系呢？

引入RTTI，其存储着类运行的相关信息， 比如类的名字，以及类的基类。下面就介绍RTTI。

## 2. RTTI （Run Time Type info) ##

这个神奇的东西用于存储类的相关信息，用于在运行时识别类对象的信息。C++ 里面只记录的类的名字和类的继承关系链。使得编译成二进制的代码，对象可以知道自己的名字（ASCII），以及在继承链中的位置。

C++ 里面提供 一个关键字 typeid ， 一个数据类型 typeinfo，以及对应的头文件 typeinfo.h

![复制代码][copycode.gif]

1 
        
         #include 
        
         <
        
         iostream
        
         >
        
         
        
         2 
        
         #include 
        
         <
        
         typeinfo
        
         >
        
         
        
         3 
        
          
        
         using
        
         
        
         namespace
        
         std; 
        
         4 
        
         
        
         5 
        
          
        
         class
        
         Base 
        
         6 
        
         { 
        
         7 
        
          
        
         public
        
         : 
        
         8 
        
         
        
         virtual
        
         
        
         void
        
         f() {} // it must need the virtual table 
        
         9 
        
         }; 
        
         10 
        
         
        
         11 
        
         
        
         12 
        
          
        
         class
        
         Derive: 
        
         public
        
         Base 
        
         13 
        
         { 
        
         14 
        
         
        
         15 
        
         }; 
        
         16 
        
         
        
         17 
        
         
        
         18 
        
          
        
         class
        
         Derive2: 
        
         public
        
         Base 
        
         19 
        
         { 
        
         20 
        
         
        
         21 
        
         }; 
        
         22 
        
         
        
         23 
        
          
        
         void
        
         f(Base
        
         *
        
         pbase) 
        
         24 
        
         { 
        
         25 
        
         
        
         const
        
         type_info
        
         &
        
         typeinfo 
        
         =
        
         typeid(pbase); 
        
         26 
        
         cout 
        
         <<
        
         typeinfo.name()
        
         <<
        
         endl; 
        
         27 
        
         
        
         28 
        
         
        
         29 
        
         
        
         if
        
         (NULL 
        
         !=
        
         dynamic_cast
        
         <
        
         Derive
        
         *>
        
         (pbase)) 
        
         30 
        
         { 
        
         31 
        
         cout
        
         <<
        
         "
        
         type: Derive
        
         "
        
         <<
        
         endl; 
        
         32 
        
         } 
        
         33 
        
         
        
         else
        
         
        
         if
        
         (NULL 
        
         !=
        
         dynamic_cast
        
         <
        
         Derive2
        
         *>
        
         (pbase)) 
        
         34 
        
         { 
        
         35 
        
         cout
        
         <<
        
         "
        
         type: Derive2
        
         "
        
         <<
        
         endl; 
        
         36 
        
         } 
        
         37 
        
         
        
         else
        
         
        
         38 
        
         { 
        
         39 
        
         
        
         //
        
         ASSERT(0)
        
         
        
         40 
        
          
        
         } 
        
         41 
        
         } 
        
         42 
        
         
        
         43 
        
         
        
         44 
        
          
        
         int
        
         main() 
        
         45 
        
         { 
        
         46 
        
         Base 
        
         *
        
         pbase1 
        
         =
        
         
        
         new
        
         Derive(); 
        
         47 
        
         f(pbase1); 
        
         48 
        
         
        
         49 
        
         Base
        
         *
        
         pbase 
        
         =
        
         
        
         new
        
         Derive2(); 
        
         50 
        
         f(pbase); 
        
         51 
        
         }

![复制代码][copycode.gif]

out put:

1 
        
         class
        
         Base 
        
         *
        
         
        
         2 
        
         type: Derive 
        
         3 
        
          
        
         class
        
         Base 
        
         *
        
         
        
         4 
        
         type: Derive2

可见 Dynamic 是运行时确定的，是安全的。 那么

1. RTTI 的信息如何和对象绑定在一起？什么时候绑定的？

2. 为什么dynam\_cast 必须要求转换的类型之间要有虚函数？否则编译通不过。

下面来回答这个问题。

## **3.RTTI 如何与对象绑定** ##

google，找资料。 下面的图来自于 “Inside C++ Model”， RTTI 的info 是如何和对象之间的关系：

![复制代码][copycode.gif]

class
        
         Point { 
        
         public
        
         : Point( 
        
         float
        
         xval ); 
        
         virtual
        
         
        
         ~
        
         Point(); 
        
         float
        
         x() 
        
         const
        
         ; 
        
         static
        
         
        
         int
        
         PointCount(); 
        
         protected
        
         : 
        
         virtual
        
         ostream
        
         &
        
         print( ostream 
        
         &
        
         os ) 
        
         const
        
         ; 
        
         float
        
         _x; 
        
         static
        
         
        
         int
        
         _point_count; };

![复制代码][copycode.gif]

其内存中模型：

![2011030621295291.jpg][]

明显RTTI info 存在于虚表的第一项。第二个问题就可以回答，因为RTTI 依赖于虚表，所以用dynamic\_cast 对应的类一定要有虚函数。

下面在VC中验证一下，

在VC中，我们知道虚指针指向虚表，对应的虚表第一项就是第一个虚函数。如果我们认为虚函数构成虚表，那么就可以认为RTTI info 就走虚表的紧邻上面。

下面验证：

1. 在VC 中查看RTTI中类名字

![2011030621513349.jpg][]

从上面图表可见，RTTI 对应的内容是空的。那么VC的实现和 书中的模型不一致吗？难道RTTI不在虚表的上面吗 ？接着有了下面的验证：

2. 把虚表上面指向RTTI info 的地址，给设置为0, 那么typeid 还可以工作吗？ Dynamic\_cast 还可以工作吗？如果还可以工作，则说明这个地址指向的数据无关。

![2011030622131870.jpg][]

如果将虚表上的RTTI的指针置空，dynamic\_cast 就不能运行,抛出异常“std:: \_\_non\_rtti\_object” . 那说明这个地址，还是与RTTI有关。 那问题出在哪里？

尝试在google 里面搜索，但是未果。 那么Dynamic\_cast 的依赖于 RTTI的信息，那么Dynamic\_cast的实现着手看看. 查看一下 他的汇编代码。 于是有了下面的实验。

3. RTTI 在VC里面如何实现的。

将上面的代码以汇编形式输出，查看。

![复制代码][copycode.gif]

24
        
         : Derive * pderive = dynamic_cast<Derive*>(pbase)
        
         ; 
        
         
        
         push
        
         
        
         0
        
         
        
         push
        
         OFFSET ??_R0?AVDerive@@@8 
        
         push
        
         OFFSET ??_R0?AVBase@@@8 
        
         push
        
         
        
         0
        
         
        
         mov
        
         eax, DWORD PTR _pbase$[ebp] 
        
         push
        
         eax 
        
         call
        
         ___RTDynamicCast 
        
         add
        
         esp, 
        
         20
        
         
        
         ;
        
         00000014H
        
         
        
         
        
         mov
        
         DWORD PTR _pderive$[ebp], eax

![复制代码][copycode.gif]

发现 dynamic\_cast的实现依赖于 对象本身，以及 ??\_R0?AVDerive@@@8 和 ??\_R0?AVBase@@@8 .  于是继续查看代码

原来虚表上面指向是一个 Derive::`RTTI Complete Object Locator 。 用google 搜索下面的该关键字，有了下面的文章
    http://www.openrce.org/articles/full_view/23
    和该图：

谜底揭晓： 原来虚表上面的地址是指向一个结构 Derive::\`RTTI Complete Object Locator ， 这个结构指向该类的名字，和其对象继承链。

这就回答了第一个问题，RTTI info 如何和对象绑定的？ 在对象创建的时候，调用构造函时候，创建虚表以及RTTI info，这样dynamic cast 就可以去访问RTTI，从而保证安全。

同样有个一问题，那就是RTTI 效率底下，试下如果一个类其继承多层，而且有多继承，那么查找链就相当遍历一个链表。

## 4. 实现一个代码用来从RTTI中读取类名字 ##

![复制代码][copycode.gif]

1 
        
         #include 
        
         "
        
         iostream
        
         "
        
         
        
         2 
        
         #include 
        
         "
        
         string
        
         "
        
         
        
         3 
        
         #include 
        
         <
        
         typeinfo
        
         >
        
         
        
         4 
        
         
        
         using
        
         
        
         namespace
        
         std; 
        
         5 
        
         
        
         6 
        
         
        
         7 
        
         
        
         class
        
         Base 
        
         8 
        
         { 
        
         9 
        
         
        
         public
        
         : 
        
         10 
        
         
        
         virtual
        
         
        
         void
        
         f() { } 
        
         11 
        
         }; 
        
         12 
        
         
        
         13 
        
         
        
         class
        
         Derive : 
        
         public
        
         Base 
        
         14 
        
         { 
        
         15 
        
         }; 
        
         16 
        
         
        
         17 
        
         typedef unsigned 
        
         long
        
         DWORD; 
        
         18 
        
         
        
         19 
        
         
        
         struct
        
         TypeDescriptor 
        
         20 
        
         { 
        
         21 
        
         DWORD ptrToVTable; 
        
         22 
        
         DWORD spare; 
        
         23 
        
         
        
         char
        
         name[ ]; 
        
         24 
        
         }; 
        
         25 
        
         
        
         struct
        
         RTTICompleteObjectLocator 
        
         26 
        
         
        
         27 
        
         { 
        
         28 
        
         
        
         29 
        
         DWORD signature; 
        
         //
        
         always zero ?
        
         
        
         30 
        
         
        
         
        
         31 
        
         DWORD offset; 
        
         //
        
         offset of this vtable in the complete class
        
         
        
         32 
        
         
        
         
        
         33 
        
         DWORD cdOffset; 
        
         //
        
         constructor displacement offset
        
         
        
         34 
        
         
        
         
        
         35 
        
         
        
         struct
        
         TypeDescriptor
        
         *
        
         pTypeDescriptor; 
        
         //
        
         TypeDescriptor of the complete class
        
         
        
         36 
        
         
        
         
        
         37 
        
         
        
         int
        
         
        
         *
        
         ptr; 
        
         38 
        
         
        
         //
        
         struct RTTIClassHierarchyDescriptor* pClassDescriptor; 
        
         //
        
         describes inheritance hierarchy
        
         
        
         39 
        
         
        
         
        
         40 
        
         }; 
        
         41 
        
         
        
         42 
        
         
        
         43 
        
         
        
         int
        
         main() 
        
         44 
        
         { 
        
         45 
        
         
        
         46 
        
         Base 
        
         *
        
         pderive 
        
         =
        
         
        
         new
        
         Derive(); 
        
         47 
        
         
        
         48 
        
         
        
         int
        
         
        
         **
        
         ptr 
        
         =
        
         (
        
         int
        
         
        
         **
        
         )(
        
         &
        
         pderive); 
        
         49 
        
         
        
         50 
        
         
        
         int
        
         
        
         *
        
         ptable 
        
         =
        
         (
        
         int
        
         
        
         *
        
         )(
        
         *
        
         (
        
         int
        
         
        
         *
        
         )(
        
         *
        
         ptr)); 
        
         51 
        
         
        
         52 
        
         
        
         int
        
         
        
         *
        
         rtti 
        
         =
        
         ptable 
        
         -
        
         1
        
         ; 
        
         53 
        
         
        
         54 
        
         RTTICompleteObjectLocator 
        
         *
        
         RIIT_locator 
        
         =
        
         (RTTICompleteObjectLocator 
        
         *
        
         )( 
        
         *
        
         (
        
         int
        
         *
        
         )rtti); 
        
         55 
        
         
        
         56 
        
         cout
        
         <<
        
         RIIT_locator
        
         ->
        
         pTypeDescriptor
        
         ->
        
         name
        
         <<
        
         endl; 
        
         57 
        
         
        
         58 
        
         }

![复制代码][copycode.gif]

Out put:

.?AVDerive@@

当然可以根据RTTI的信息，可以遍历其继承关系图。留作一个练习，可以尝试一下。

总结：

static\_cast 用于数值类型之间的转换，也可以用于指针之间的转换，编译的已经确定好，效率高，但须要自己保证其安全性。

dynamic\_cast 用于有继承关系的类之间转换，是基于RTTI数据信息的，运行时检测，安全，但是效率低。

Refernce：

RTTI intoduction：

1. http://www.rcs.hu/Articles/RTTI\_Part1.htm \[介绍RTTI 的应用，需要的借口，以及一个实现\]

2. http://www.codeproject.com/KB/cpp/dynamic\_cpp.aspx

[Dynamic_cast _ RTTI]: http://www.cnblogs.com/zhyg6516/archive/2011/03/07/1971898.html
[copycode.gif]: /images/20221022/23d39bb4699549c68ac9440267fddc00.png
[2011030621295291.jpg]: /images/20221022/19fed12d528e449cabb105655db1f45e.png
[2011030621513349.jpg]: /images/20221022/20d695fb6cb9419baad742f5ffbcff6a.png
[2011030622131870.jpg]: /images/20221022/79f7f7b0e4d04772b4d6c3c1832605cd.png