本文主要是介绍C++ day34 RTTI,dynamic_cast,typeid,type_info,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!
文章目录
- RTTI(C++新增特性):只可用于有虚函数的类!
- 为什么要在运行阶段知道类型?
- RTTI只可以用于包含虚函数的类层次结构
- 如何实现
- dynamic_cast运算符(最常用的RTTI组件):生成一个指向派生类的指针
- 示例:dynamic_cast的使用
- 把dynamic_cast运算符和引用结合使用(一般是和指针一起用)
- typeid运算符和type_info类
- 示例
- 应先考虑使用dynamic_cast和虚函数,然后才考虑typeid
- 总结
RTTI(C++新增特性):只可用于有虚函数的类!
runtime type identification
- 目的:为在运行阶段确定对象类型提供一种标准方式。
- 现状:由于是新加的,所以C++内部还不支持,只有很多厂商的类库提供了实现方式,但是不同厂商的实现方式又千差万别的,互不兼容。现状略惨。
为什么要在运行阶段知道类型?
- 想要调用类方法的正确版本
如果想调用的函数是虚函数,则类层次结构中的所有类都拥有这个函数,类层次中的所有类的对象都可以调用这个方法,根本不需要知道这些对象具体的类型是哪个派生类。
但是,如果想要调用的函数不是类层次的所有类都拥有的虚函数,而是某个派生类自己添加的新方法,那么就必须要确定对象的类型,才可以为它调用到正确的那个方法。
- 出于调试目的,想要跟踪生成的对象的类型。
RTTI只可以用于包含虚函数的类层次结构
因为只有这种层次结构,才可以把派生类对象的地址赋给基类的指针。
如何实现
dynamic_cast运算符(最常用的RTTI组件):生成一个指向派生类的指针
它使用一个指向基类的指针,生成一个指向派生类的指针。如果生成不了,就返回空指针0。
语法:
dynamic_cast<Type *>(pt);//如果指针pt指向的对象(*pt)的类型就是Type,或者是从Type直接或间接派生得到的类型,则会把pt转换为Type类型的指针,否则返回0,空指针
它并不可以直接回答出指针指向的是哪一个类,而是回答类型转换是否安全,即是否可以把对象的地址赋给某个类的指针,这么赋值安不安全。
回答类型转换是否安全是更通用的,也是更有用的。因为我想知道类型,一般就是为了看看调用某个方法安不安全,并不需要类型一定匹配。所以就不需要告诉我具体类型,而是告诉我转换安全与否。
举个例子:
Superb是Magnificent的直接基类,Grand是其间接基类。
上图的三个类型转换,在代码上不会出错,但是就安全性而言:第一个和第三个类型转换是安全的,而第二个不安全。第一个是自己转自己,没的说。第三个是派生类转基类,可以,因为基类指针可以指向派生类对象;第2个,基类转派生类,这就不行了,你就算转了,这个对象他也没有派生类的方法和数据啊,所以这种转换是不安全的不允许的。
语法:
Superb * pm = dynamic_cast<Superb *>(pg); //指针pg是否可以安全地转换为Superb *?如果可以,则返回转换后对象的地址,否则就返回一个空指针
示例:dynamic_cast的使用
写了一个类层次里的三个类,层次如下图:
//rtti.cpp -- using the rtti dynamic_cast operator
#include <iostream>
#include <cstdlib>
#include <ctime>using std::cout;
class Grand{
private:int hold;
public:Grand(int h = 0):hold(h){}virtual void Speak() const {cout << "I am a grand class!\n";}virtual int Value() const {return hold;}
};class Superb: public Grand{
public:Superb(int h = 0):Grand(h){}//???公有继承可以继承基类的私有数据??void Speak() const {cout << "I am a superb class!\n";}//重写基类虚方法virtual void Say() const{cout << "I hold the superb value of " << Value() << "!\n";}//调用基类方法Value()
};class Magnificent:public Superb{
private:char ch;
public:Magnificent(int h = 0, char c = 'A'):Superb(h), ch(c){}//只需要调用直接基类的构造函数void Speak() const {cout << "I am a magnificent class!\n";}void Say() const {cout << "I hold the character of " << ch << " and the integer of " << Value() << "!\n";}//调用基类方法Value()
};Grand * GetOne();int main()
{std::srand(std::time(0));//设置随机种子Grand * pg;Superb * ps;for (int i = 0;i<5;++i){pg = GetOne();pg->Speak();if (ps = dynamic_cast<Superb *>(pg))ps->Say();std::cout << std::endl;}return 0;
}Grand * GetOne()//随机生成三种类型之一的对象
{Grand * p;switch(std::rand() % 3){case 0:p = new Grand(std::rand() % 100);break;case 1:p = new Superb(std::rand() % 100);break;case 2:p = new Magnificent(std::rand() % 100, 'A' + std::rand() % 26);break;}return p;
}
从结果可以看到,只有Superb和Magnificent类的对象调用了Say方法。
I am a superb class!
I hold the superb value of 75!I am a magnificent class!
I hold the character of E and the integer of 36!I am a grand class!I am a grand class!I am a superb class!
I hold the superb value of 54!
问题和收获:
- 虽然GetOne函数生成的对象都赋值给了Grand指针,但是他们还是他们自己类的对象,并不会因为赋值给Grand类指针就完全变性,变成Grand对象哦。比如Superb对象,它包含了一个Grand对象,现在把它赋给Grand对象,并不会导致除了它包含的Grand对象之外的数据和方法没了。即它的本质不会变,还是Superb对象,这个是由它的对象结构决定的。不是一句赋值就能改变的。
- 通过写这个代码,我复习了公有继承的知识。写到Superb类的构造函数的这句代码
Superb(int h = 0):Grand(h){}//???公有继承可以继承基类的私有数据??
时,我很震惊,毕竟hold是基类Grand的私有数据,可是就算是公有继承,也无法继承到基类的私有数据啊。咋回事,然后我就回去看了看我这篇讲公有继承的博文,发现原来派生类对象都会包含一个自己的基类的对象,所以必须要给基类的所有数据包括私有数据和保护数据赋值,只不过由于没有访问权限,所以要调用基类的构造函数进行赋值。并且赋值顺序必须是先给基类的数据用基类构造函数赋值,然后才给自己的新数据赋值。
- 通过写GetOne函数(使用rand函数来随机选择对象的类型),我学到了灵活使用随机数。随机数的使用和生成我一直不是很熟悉,尤其是这个srand方法,现在觉得好像明白了,就用它生成种子而已。然后随机数的生成和取模运算符,以及switch语句的巧妙配合,我觉得很棒棒。
- 还复习到了虚函数,基类的虚函数可以有自己的定义,然后派生类可以修改定义。基类的非虚方法只能被继承和直接使用(比如这里的Value()函数),不能自己再修改。类层次中的中间的派生类仍然可以随意添加虚方法,让自己的派生类继承和修改实现。
虚方法真是个好东西,继承的一大利器啊,有利于代码重用。
把dynamic_cast运算符和引用结合使用(一般是和指针一起用)
像上面的示例,都是用的指针,用指针的好处是:如果转换不安全,则可以用空指针来表示。用引用就无法指示出转换不安全了,因为没有空引用这个说法。
其实除此之外,用指针还是引用都没有区别。所以如果你非要用引用,那就用异常处理手段(type_info头文件的bad_cast类的异常)来弥补无法说明转换不安全的缺陷:
#include <type_info>
···
try{Superb & s = dynamic_cast<Superb &>(p);
}
catch(bad_cast & bc)
{···
}
所以其实能用指针就用指针吧,完全没必要用引用,二者一样的,别搞幺蛾子了,非要用引用然后用更复杂的异常处理,我觉得炫技的嫌疑。
typeid运算符和type_info类
typeid运算符返回一个对type_info对象的引用(引用当然就可以指明对象类型啦)
type_info是头文件typeinfo中定义的一个类。type_info类重载了==和!=运算符,以便于用来比较两个类型。
type_info类的实现也是因厂商而异的。但是都会有一个name()方法,这个方法返回一个字符串,一般是类名。
cout << "Now processing type " << typeid(*pg).name() << ".\n";
typeid运算符返回一个值,这个值是一个对type_info对象的引用,所以可以指明对象的类型。
typeid运算符的输入可以是类名,也可以是对象。
bool isEqual = typeid(Magnificent) == typeid(*pg);//如果pg指向的是magnificent类的对象,则为true
//如果pg是空指针,则会引发bad_typeid异常,是从exception类派生得到的,在typeinfo中声明。
示例
//rtti.cpp -- using the rtti dynamic_cast operator
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <typeinfo>using std::cout;
class Grand{
private:int hold;
public:Grand(int h = 0):hold(h){}virtual void Speak() const {cout << "I am a grand class!\n";}virtual int Value() const {return hold;}
};class Superb: public Grand{
public:Superb(int h = 0):Grand(h){}//???公有继承可以继承基类的私有数据??void Speak() const {cout << "I am a superb class!\n";}//重写基类虚方法virtual void Say() const{cout << "I hold the superb value of " << Value() << "!\n";}//调用基类方法Value()
};class Magnificent:public Superb{
private:char ch;
public:Magnificent(int h = 0, char c = 'A'):Superb(h), ch(c){}//只需要调用直接基类的构造函数void Speak() const {cout << "I am a magnificent class!\n";}void Say() const {cout << "I hold the character of " << ch << " and the integer of " << Value() << "!\n";}//调用基类方法Value()
};Grand * GetOne();int main()
{std::srand(std::time(0));//设置随机种子Grand * pg;Superb * ps;for (int i = 0;i<5;++i){pg = GetOne();cout << "Now processing type " << typeid(*pg).name() << ".\n";pg->Speak();if (ps = dynamic_cast<Superb *>(pg))ps->Say();if (typeid(Magnificent) == typeid(*pg))cout << "Yes, you are really magnificent!\n";std::cout << std::endl;}return 0;
}Grand * GetOne()//随机生成三种类型之一的对象
{Grand * p;switch(std::rand() % 3){case 0:p = new Grand(std::rand() % 100);break;case 1:p = new Superb(std::rand() % 100);break;case 2:p = new Magnificent(std::rand() % 100, 'A' + std::rand() % 26);break;}return p;
}
输出类型名时,有的编译器会在前面加一个数字(有的不会),大概这个数字就是typeid运算符返回的数值吧。
Now processing type 6Superb.
I am a superb class!
I hold the superb value of 89!Now processing type 6Superb.
I am a superb class!
I hold the superb value of 97!Now processing type 6Superb.
I am a superb class!
I hold the superb value of 26!Now processing type 6Superb.
I am a superb class!
I hold the superb value of 24!Now processing type 11Magnificent.
I am a magnificent class!
I hold the character of Q and the integer of 38!
Yes, you are really magnificent!
应先考虑使用dynamic_cast和虚函数,然后才考虑typeid
不要滥用typeid,说实话,我学了typeid后,也觉得很好用,但是不要像下面这样用,写出毫无必要的冗长且不好维护的代码:
这个代码,用typeid来分别测试每一个类,虽然好像逻辑很好,其实一点都不聪明。很多人就是因为有这种代码的存在而对typeid深恶痛绝。。如果增加一个新的类,则需要增加一个else分支,还需要自己判断能不能执行么每一个函数。。。何必呢。继承和虚函数明明提供了简洁优雅的康庄大道,偏不走,要来走这犄角旮沓。
如果用dynamic_cast和虚函数,代码就是下面这样,非常简洁,且就算要在类层次中增加一个新的类,这部分代码也不需要修改。pg->Speak();ps->Say();
还是会很好的运转。
pg->Speak();
可以用于所有从Grand类派生的类
ps->Say();
适用于所有从Superb类派生来的类。
Grand * pg;
Superb * ps;
for (int i = 0;i<5;++i)
{pg = GetOne();pg->Speak();if (ps = dynamic_cast<Superb *>(pg))ps->Say();std::cout << std::endl;
}
总之,typeid绝对是个好工具,不像异常规范那样看似很好实际不好,它是真的有用的,但是不要因为它好用就滥用它,写出这种没必要的代码,应该尽量使用继承和虚函数的那种简洁和便利方式。
总结
- dynamic_cast把派生类指针转为基类指针(向上转换),以确保可以安全地调用虚函数。
- typeid返回一个type_info对象,通过这个对象可以获得类型信息。
- 可以把两个typeid的返回值比较,以确定对象是否是某个特定类型。
这篇关于C++ day34 RTTI,dynamic_cast,typeid,type_info的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!