c++ RTTI机制和类型转化

        RTTI 是“Runtime Type Information”的缩写，意思是：运行时类型信息。它提供了运行时确定对象类型的方法。C++数据类型是在编译期就确定的，不能在运行时更改。然而由于面向对象程序设计中多态性的要求，C++中的指针或引用(Reference)本身的类型，可能与它实际代表(指向或引用)的类型并不一致。有时我们需要将一个多态指针转换为其实际指向对象的类型，就需要知道运行时的类型信息，这就产生了运行时类型识别的要求，C++没有Java，golang等获取对象类型的反射机制，要想获得运行时类型信息，只能通过RTTI机制。

      RTTI使程序能够获取由基指针或引用所指向的对象的实际派生类型，即允许“用指向基类的指针或引用来操作对象”的程序能够获取到“这些指针或引用所指对象”的实际派生类型。在C++中，为了支持RTTI提供了两个操作符：dynamic_cast和typeid。

     

  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85

#include <vector>
#include <iostream>
#include <string>
class Base
{
public:
    int a;
    char b;
    virtual void Say()
    {
        std::cout << "Base Say" <<  std::endl;
    }
    void Talk()
    {
        std::cout << "Base Talk" <<  std::endl;
    }
};
class A : public Base
{
public:
    int Aa;
    char Ab;
    virtual void Say()
    {
        std::cout << "A Say" <<  std::endl;
    }
    void Talk()
    {
        std::cout << "A Talk" <<  std::endl;
    }
};
class B : public A
{
public:
    char Bc;
    virtual void Say()
    {
        std::cout << "B Say" <<  std::endl;
    }
    /*virtual*/ void Talk()             //注释1
    {
        std::cout << "B Talk" <<  std::endl;
    }
};
int main()
{
    A* a = new A;
    Base* b = (Base*) a;
    std::cout << "type of *b: " << typeid(*b).name() <<  std::endl;
    b->Say();
    b->Talk();
    std::cout << "***************************************" <<  std::endl;
    B* c = dynamic_cast<B*>(a);
    std::cout << "type of *c: " << typeid(c).name() <<  std::endl;
    if (c != NULL){
        c->Say();
        c->Talk();
    }else{
        std::cout << "c is NULL " <<  std::endl;
    }
    std::cout << "***************************************" <<  std::endl;
    B* d = (B*) a;
    std::cout << "type of *d: " << typeid(*d).name() <<  std::endl;
    if (d != NULL){
        d->Say();
        d->Talk();  //标记1
    }else{
        std::cout << "d is NULL " <<  std::endl;
    }
    std::cout << "***************************************" <<  std::endl;
    A* e = new B;
    B* f = dynamic_cast<B*>(e);
    std::cout << "type of *f: " << typeid(c).name() <<  std::endl;
    if (f != NULL){
        f->Say();
        f->Talk();
    }else{
        std::cout << "f is NULL " <<  std::endl;
    }
}

 来自CODE的代码片

rtti.cpp

      执行结果：

      

     如果表达式的类型是类类型且至少包含有一个虚函数，则typeid操作符返回表达式的动态类型，需要在运行时计算；否则，typeid操作符返回表达式的静态类型，在编译时就可以计算。这一点我们根据三个type of的输出结果可以得出结论。

    对于c++的类型转换有隐式和显式两种形式，隐式的转换主要对于c++的内置基本类型，对于用户自定义的需要进行显式的转换。

    C++父类和子类对象指针之间的转换 由子类向父类转换很简单, 用默认转换.

    由父类向子类, 用dynamic_cast. 使用dynamic_cast是有限制的，我们最后一段代码转化成功是因为指针e的动态类型本来就是B类型的。对于这点注意一下上面注释部分的代码，如果我们打开注释，程序将会崩溃在标记处，如果我们强行把父类转换为子类，此时转换后的子类信息是不完整的，如果我们调用了子类独有的变量或者函数将会出错。

   但是用 dynamic_cast来转换情况情况就会好很多，他首先会判断转换能不能成功，如果不能将会将会返回一个null值，这点在一个很复杂的继承系统特别是多重继承中是很有用的，如果我们在类型转换时不确定能不能转换成功，我们可以用这一点，尝试进行转换，而不是强制转换，转换后根据是否为null来确定是否成功。

  更多关于c++的类型转换推荐一篇文章给大家：点击打开链接