C++ day34 RTTI，dynamic

C++ day34 RTTI，dynamic

文章目录

• 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的返回值比较，以确定对象是否是某个特定类型。