运行时类型识别RTTI

1、什么是RTTI？

RTTI：Run-Time Type Identification运行时类型识别

程序在运行时能够使用基类的指针或引用来检查这些指针或引用所指的对象的实际的派生类。

在这里要用到两个C++中的关键字：typeid和dynamic_cast

2、typeid

typeid是C++中一个用来获取变量类型的关键字，用法跟使用函数一样 typeid(xxx)

typeid注意事项：

(1)typeid返回的是一个type_info对象的引用，而这个引用是与具体的变量类型有关的，

也就是说不同的变量类型都有一个type_info结构体。type_info结构体如下：

class type_info{
public:
     const char* name() const;        //  打印具体类型的方法  一般这样用 typeid(x1).name()
     bool operator==(const type_info& rhs) const;  // 运算符重载  支持直接 typeid(x1) == typeid(x2)
     bool operator!=(const type_info& rhs) const;   // 运算符重载
     int before(const type_info& rhs) const;
     virtual ~type_info();        // 析构函数
private:
     ......
};

 

(2)xxx可以是一个变量名(typeid(a))，也可以是一个具体的变量类型(typeid(int))，通常是用来做比较的时候，如下例子所示：

int  i  =  0;
cout << typeid(i).name() << endl;    // int型变量 i
cout << typeid(&i).name() << endl;   // int *变量 &i
if (typeid(i) == typeid(int)) {  }

(3)如果我们想通过基类的指针获得派生类的数据类型，基类必须带有虚函数，否则获取的就是基类的类型，并且只能够去获取派生类对象的实际类型，

也就是说我们typeid传参的时候只能是对象类型或者是对象引用，不能是对象指针（注意我这里说的是你想要通过基类获取派生类对象数据类型）

背景：因为我们可以通过基类的指针变量指向一个派生类变量的地址，而typeid关键字提供了使用基类指针去获取派生类对象的数据类型。

#include <iostream>
using namespace std;

class Fly1{
public:
    virtual void fly(void);     //  Fly1基类中含有虚函数
};

class Fly2{
public:
    void fly(void) ;         // Fly2基类中不含虚函数
};

class Plane1 : public Fly1   // Plane1派生类继承于Fly1
{
public:
    virtual void fly(void);
    void transport(void);
};

class Plane2 : public Fly2    // PLane2派生类继承于Fly2
{
public:
    virtual void fly(void);
    void transport(void);
};

/****************************************/
void Fly1::fly(void)
{
     cout << "fly---Fly1" << endl;
}

void Fly2::fly(void)
{
     cout << "fly---Fly2" << endl;
}

void Plane1::fly(void)
{
     cout << "fly---Plane1" << endl;
}

void Plane2::fly(void)
{
     cout << "fly---Plane2" << endl;
}

int main(void)
{
      Fly1 *fly1 = new Plane1();
      Fly2 *fly2 = new Plane2();

      cout << typeid(fly1).name() << endl;
      cout << typeid(*fly1).name() << endl;
      cout << typeid(fly2).name() << endl;
      cout << typeid(*fly2).name() << endl;

      return 0;
}

 

运行结果如下:

  

因为基类Fly1中含有虚函数，并且fly1是一个指针，所以第一行显示就是基类指针变量的类型，而第二行因为传参就是指针指向的对象（也就是对象实际类型），所以能够获取到派生类对象的类型

因为基类Fly2中不含虚函数，所以不管传入的是对象指针还是对象本身，获取的都是基类对应的类型，而不能获取到派生类对象的类型。

所以说要通过基类指针获取派生类对象的类型：第一条件是基类中含有虚函数  第二条件：只能获取派生类对象的类型，不能获取派生类对象指针的类型。  

 

3、dynamic_cast

dynamic_cast主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换。

(1)用法：dynamic_cast<type-id>(expression)   type-id就是要转换的类型，expression就是待转换的变量，所以dynamic_cast就是将expression变量转化          为type-id类型的变量，type-id必须是类的指针、类的引用或者是void *。

(2)返回值：对指针进行dynamic_cast，失败返回null，成功返回正常cast后的对象指针；
           对引用进行dynamic_cast，失败抛出一个异常，成功返回正常cast后的对象引用。

(3)多态类型间转换的3种类型： 子类转为父类的向上转换、父类转为子类的向下转换、平行类间的横向转换（指的是多继承的情况下，各个父类之间的转换）

其中向下转换和横行转换要求被转换的类中必须含有虚函数，否则不能转换成功；而向上转换并没有这个要求。

#include <iostream>
using namespace std;

class tao1
{
public:
     virtual void a(void) { cout << "a---tao1" << endl; }
};

class tao2
{
public:
    virtual void a(void) { cout << "a---tao2" << endl; }
};

class tao3 : public tao2, public tao1
{
public:
    virtual void a(void) { cout << "a---tao3" << endl; }
};


int main(void)
{
    /*向上转换*/
//    tao3 *pTao3 = new tao3();
//    tao1 *pTao1 = dynamic_cast<tao1 *>(pTao3);   

    /*向下转换*/
//    tao1 *pTao1 = new tao3();
//    tao3 *pTao3 = dynamic_cast<tao3 *>(pTao1);  // 要求被转换的类中函数虚函数

    /*横向转换*/
    tao1 *pTao1 = new tao3();
    tao2 *pTao2 = dynamic_cast<tao2 *>(pTao1);  // 要求被转换的类中含有虚函数

    return 0;
}

代码如下：

4、使用typeid和dynamic_cast构建RTTI

背景：在程序中常常需要这样的操作，当我们的一个函数的参数是一个基类指针的时候，而我们调用这个函数传入的参数是一个派生类指针

      所以我们需要在函数中通过typeid判断我们的派生类对象的类型，然后通过dynamic_cast将我们的基类对象转换为派生类对象，从而可以

      调用派生类中相应的方法进行操作。

代码如下：

#include <iostream>
#include <string>
using namespace std;

class Fly{
public:
    virtual void fly(void) = 0;
};

class Plane : public Fly
{
public:
    virtual void fly(void);
    void transport(void);
};

class Bird : public Fly
{
public:
    virtual void fly(void);
    void eat(void);
};

/*******************************************/
void Plane::fly(void)
{
    cout << "fly---Plane" << endl;
}

void Plane::transport(void)
{
    cout << "transport---Plane" << endl;
}

/***************************************************/
void Bird::fly(void)
{
    cout << "fly---Bird" << endl;
}

void Bird::eat(void)
{
    cout << "eat---Bird" << endl;
}

/*********************************************/
static void doSomeThing(Fly *obj)
{
    obj->fly();

    if (typeid(*obj) == typeid(Plane))   // 判断传进来的指针指向的对象的类型
    {
        Plane *ptr = dynamic_cast<Plane *>(obj); // 转换类型
        ptr->transport();
    }

    if (typeid(*obj) == typeid(Bird))
    {
        Bird *ptr = dynamic_cast<Bird *>(obj);
        ptr->eat();
     }
}

int main(void)
{
    Plane pla;
    Bird bir;
    doSomeThing(&pla);
    doSomeThing(&bir);
    return 0;
}

 运行结果如下：