当前位置：首页 > news >正文

C++运行时类型识别RTTI

news 2025/9/16 13:14:51

C++技能 runtime type identification(RTTI)

运行时类型识别

在使用多态的时候经常用到。本文将会介绍RTTI的几个特征。

1. 运行时类型转换

下面的程序模仿了dynamic_cast<type_id>()类型转化符号，根据每个类的id来判断当前的类型，如果id不匹配，则调用dynacast函数会转化失败

#include <iostream>
#include<vector>
using namespace std;//base class
class Security{
protected:enum{BASEID = 0};public:virtual ~Security(){}virtual bool isA(int id){return id == BASEID;}
};///继承基类 
class Stock : public Security{typedef Security Super;
protected:enum{ OFFSET = 1, TYPEID = BASEID + OFFSET};
public:bool isA(int id){return id == TYPEID || Super::isA(id);}//类型转换--通过检查id来判断，基类的id = 0,stock id = 1,如果当前id = stock id,则允许向下转换，否则返回NULL static Stock* dynacast(Security* s){return (s->isA(TYPEID)) ? static_cast<Stock*>(s) : 0;}
};//继承了基类 
class Bond : public Security{typedef Security Super;
protected:enum{ OFFSET = 2, TYPEID = BASEID + OFFSET};
public:bool isA(int id){return id == TYPEID || Super::isA(id);}static Bond* dynacast(Security* s){return (s->isA(TYPEID)) ? static_cast<Bond*>(s) : 0;}
};//继承了基类 
class Investment : public Security{typedef Security Super;
protected:enum{ OFFSET = 3, TYPEID = BASEID + OFFSET};
public:bool isA(int id){return id == TYPEID || Super::isA(id);}static Investment* dynacast(Security* s){return (s->isA(TYPEID)) ? static_cast<Investment*>(s) : 0;}void special(){cout << "special Investment function\n";}
};//基类的孙子类 
class Metal : public Investment{typedef Security Super;
protected:enum{ OFFSET = 4, TYPEID = BASEID + OFFSET};
public:bool isA(int id){return id == TYPEID || Super::isA(id);}static Metal* dynacast(Security* s){return (s->isA(TYPEID)) ? static_cast<Metal*>(s) : 0;}
};int main(){vector<Security*> portfolio;//基类指向派生类们 portfolio.push_back(new Metal);portfolio.push_back(new Investment);portfolio.push_back(new Bond); portfolio.push_back(new Stock);//for(vector<Security*>::iterator it = portfolio.begin(); it != portfolio.end(); it++){Investment* cm = Investment::dynacast(*it);//指针转化if(cm)cm->special();elsecout << "not an Investment\n";} Security* sp = new Metal;Investment* cp = Investment::dynacast(sp);//根据多态理论调用对于的dynacast ,这里调用metal类的isAif(cp) cout << "it's a Investment\n";Metal* mp = Metal::dynacast(sp);//转化成功 if(mp) cout << "it's a metal\n";//释放内存for(vector<Security*>::iterator it = portfolio.begin(); it != portfolio.end(); it++){delete *it;} return 0;
}

上面是指针的转化，如果使用dynamic_cast程序会简短很多，

#include <iostream>
#include<vector>
using namespace std;//base class
class Security{
public:virtual ~Security(){}
};///继承基类 
class Stock : public Security{
};//继承了基类 
class Bond : public Security{
};//继承了基类 
class Investment : public Security{
public:void special(){cout << "special Investment function\n";}
};//基类的孙子类 
class Metal : public Investment{
};int main(){vector<Security*> portfolio;//基类指向派生类们 portfolio.push_back(new Metal);portfolio.push_back(new Investment);portfolio.push_back(new Bond); portfolio.push_back(new Stock);//for(vector<Security*>::iterator it = portfolio.begin(); it != portfolio.end(); it++){Investment* cm = dynamic_cast<Investment*>(*it);//指针转化if(cm)cm->special();elsecout << "not an Investment\n";} Security* sp = new Metal;//转化成功 Investment* cp = dynamic_cast<Investment*>(sp);if(cp) cout << "it's a Investment\n";Metal* mp = dynamic_cast<Metal*>(sp);//转化成功 if(mp) cout << "it's a Metal\n";//释放内存for(vector<Security*>::iterator it = portfolio.begin(); it != portfolio.end(); it++){delete *it;} return 0;
}

dynamic_cast要求多态，还好这里的基类的析构是虚函数，因此可以使用 dynamic_cast。另外dynamic_cast只能做指针或者引用的转化

如果是普通的类型转化，则无法用是否为空指针来判断，这时可以用异常处理，如果无法转化，dynamic_cast会抛出异常。

2.typedid操作符

typeid可以获取对象运行时的信息，他会返回一个type_info对象，该对象记录了和这个对象有关的应用信息，比如：

这个对象是多态的，则它将会给出那个应用的大部分派生类信息；否则就给出静态信息，typeid操作符的一个用途是获得一个对象的动态类型的名称

输出结果和编译器有关，有的直接输出名字，有的输出pk什么的，p代表指针，k代表const修饰符

#include <iostream>
#include<vector>
#include<typeinfo>
using namespace std;struct PolyBase{virtual ~PolyBase(){} 
}; struct PolyDer : public PolyBase{PolyDer(){}
};struct NonPolyBase{
};struct NonPolyDer : public NonPolyBase{NonPolyDer(int){    }
};int main(){const PolyDer pd;const PolyBase* ppd = &pd;//父类指向子类cout << typeid(ppd).name() << endl;//输出父类自己的名字 cout << typeid(*ppd).name() << endl; //输出子类名称 cout << boolalpha << (typeid(*ppd) == typeid(pd)) << endl;//输出true const NonPolyDer npd(1);const NonPolyBase* nppd = &npd;cout << typeid(nppd).name() << endl;//输出父类 cout << typeid(*nppd).name() << endl; //输出父类 cout << boolalpha << (typeid(*nppd) == typeid(npd)) << endl;//false int i;cout << typeid(i).name() << endl; return 0;
}

对于第一种含有虚函数，和第二种不含有虚函数是完全不同的。因为typeid对多态敏感。

使用指针的时候，输出的是指针的静态类型，当调用对象解析的时候，则会输出动态类型

而对于不含虚函数的类，则不会有变化，两次输出都是父类的名字，typeid也支持内置的类型

typeid不支持赋值操作，也没用可供访问的构造函数

3.继承体系的中间层次的转化

比如有这么一个继承体系

class B1{virtual ~B1(){}};

class B2{virtual ~B2(){}};

class MI : public B1, public B2{};

class Mi2 : public MI{};

那么创建一个Mi2对象，可以转化为MI,B1,B2;

#include <iostream>
using namespace std;class B1{public:virtual ~B1(){}
};class B2{public:virtual ~B2(){}
};class MI : public B1, public B2{};class Mi2 : public MI{};int main(){B2* b2 = new Mi2;Mi2* pmi2 = dynamic_cast<Mi2*>(b2);B1* b1 = dynamic_cast<B1*>(b2);MI* mi = dynamic_cast<MI*>(b2);return 0;
}