C++ day34 RTTI，dynamic_cast，typeid，type_info

谁践踏了优雅 2023-02-17 02:55 26阅读 0赞

### 文章目录 ###

*  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，空指针

它**并不可以直接回答出指针指向的是哪一个类**，而是**回答类型转换是否安全**，即**是否可以把对象的地址赋给某个类的指针**，这么赋值安不安全。

回答类型转换是否安全是更通用的，也是更有用的。因为我想知道类型，一般就是为了看看调用某个方法安不安全，并不需要类型一定匹配。所以就不需要告诉我具体类型，而是告诉我转换安全与否。

举个例子：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70]  
Superb是Magnificent的直接基类，Grand是其间接基类。

上图的三个类型转换，在代码上不会出错，但是就安全性而言：第一个和第三个类型转换是安全的，而第二个不安全。第一个是自己转自己，没的说。第三个是派生类转基类，可以，因为基类指针可以指向派生类对象；第2个，基类转派生类，这就不行了，你就算转了，这个对象他也没有派生类的方法和数据啊，所以这种转换是不安全的不允许的。

语法：

Superb * pm = dynamic_cast<Superb *>(pg); //指针pg是否可以安全地转换为Superb *?如果可以，则返回转换后对象的地址，否则就返回一个空指针

#### 示例：dynamic\_cast的使用 ####

写了一个类层次里的三个类，层次如下图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 1]

//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的私有数据，可是就算是公有继承，也无法继承到基类的私有数据啊。咋回事，然后我就回去看了看[我这篇讲公有继承的博文][Link 1]，发现原来派生类对象都会包含一个自己的基类的对象，所以**必须要给基类的所有数据包括私有数据和保护数据赋值**，只不过由于没有访问权限，所以要**调用基类的构造函数进行赋值**。并且赋值顺序必须是先给基类的数据用基类构造函数赋值，然后才给自己的新数据赋值。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 2]
 *  通过写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后，也觉得很好用，但是不要像下面这样用，写出毫无必要的冗长且不好维护的代码：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 3]  
这个代码，用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的返回值比较，以确定对象是否是某个特定类型。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200611162219681.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200611171221991.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[Link 1]: https://blog.csdn.net/qq_36607894/article/details/105044332
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200611164929618.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/2020061119152367.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70