C++ day34 RTTI,dynamic_cast,typeid,type_info

2024-01-08 21:20

本文主要是介绍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的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/584865

相关文章

MySQL 中的 CAST 函数详解及常见用法

《MySQL中的CAST函数详解及常见用法》CAST函数是MySQL中用于数据类型转换的重要函数,它允许你将一个值从一种数据类型转换为另一种数据类型,本文给大家介绍MySQL中的CAST... 目录mysql 中的 CAST 函数详解一、基本语法二、支持的数据类型三、常见用法示例1. 字符串转数字2. 数字

从入门到精通C++11 <chrono> 库特性

《从入门到精通C++11<chrono>库特性》chrono库是C++11中一个非常强大和实用的库,它为时间处理提供了丰富的功能和类型安全的接口,通过本文的介绍,我们了解了chrono库的基本概念... 目录一、引言1.1 为什么需要<chrono>库1.2<chrono>库的基本概念二、时间段(Durat

C++20管道运算符的实现示例

《C++20管道运算符的实现示例》本文简要介绍C++20管道运算符的使用与实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧... 目录标准库的管道运算符使用自己实现类似的管道运算符我们不打算介绍太多,因为它实际属于c++20最为重要的

Visual Studio 2022 编译C++20代码的图文步骤

《VisualStudio2022编译C++20代码的图文步骤》在VisualStudio中启用C++20import功能,需设置语言标准为ISOC++20,开启扫描源查找模块依赖及实验性标... 默认创建Visual Studio桌面控制台项目代码包含C++20的import方法。右键项目的属性:

c++中的set容器介绍及操作大全

《c++中的set容器介绍及操作大全》:本文主要介绍c++中的set容器介绍及操作大全,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考下吧... 目录​​一、核心特性​​️ ​​二、基本操作​​​​1. 初始化与赋值​​​​2. 增删查操作​​​​3. 遍历方

解析C++11 static_assert及与Boost库的关联从入门到精通

《解析C++11static_assert及与Boost库的关联从入门到精通》static_assert是C++中强大的编译时验证工具,它能够在编译阶段拦截不符合预期的类型或值,增强代码的健壮性,通... 目录一、背景知识:传统断言方法的局限性1.1 assert宏1.2 #error指令1.3 第三方解决

C++11委托构造函数和继承构造函数的实现

《C++11委托构造函数和继承构造函数的实现》C++引入了委托构造函数和继承构造函数这两个重要的特性,本文主要介绍了C++11委托构造函数和继承构造函数的实现,具有一定的参考价值,感兴趣的可以了解一下... 目录引言一、委托构造函数1.1 委托构造函数的定义与作用1.2 委托构造函数的语法1.3 委托构造函

C++11作用域枚举(Scoped Enums)的实现示例

《C++11作用域枚举(ScopedEnums)的实现示例》枚举类型是一种非常实用的工具,C++11标准引入了作用域枚举,也称为强类型枚举,本文主要介绍了C++11作用域枚举(ScopedEnums... 目录一、引言二、传统枚举类型的局限性2.1 命名空间污染2.2 整型提升问题2.3 类型转换问题三、C

C++链表的虚拟头节点实现细节及注意事项

《C++链表的虚拟头节点实现细节及注意事项》虚拟头节点是链表操作中极为实用的设计技巧,它通过在链表真实头部前添加一个特殊节点,有效简化边界条件处理,:本文主要介绍C++链表的虚拟头节点实现细节及注... 目录C++链表虚拟头节点(Dummy Head)一、虚拟头节点的本质与核心作用1. 定义2. 核心价值二

C++ 检测文件大小和文件传输的方法示例详解

《C++检测文件大小和文件传输的方法示例详解》文章介绍了在C/C++中获取文件大小的三种方法,推荐使用stat()函数,并详细说明了如何设计一次性发送压缩包的结构体及传输流程,包含CRC校验和自动解... 目录检测文件的大小✅ 方法一:使用 stat() 函数(推荐)✅ 用法示例:✅ 方法二:使用 fsee