掘根宝典之C++RTTI和类型转换运算符

2024-03-19 00:20
文章标签 c++ 运算符 类型转换 宝典 rtti 掘根

本文主要是介绍掘根宝典之C++RTTI和类型转换运算符，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

什么是RTTI

RTTI是运行阶段类型识别的简称。

哪些是RTTI?

C++有3个支持RTTI的元素。

1.dynamic_cast运算符将使用一个指向基类的指针来生成一个指向派生类的指针，否则该运算符返回0——空指针。

2.typeid运算符返回一个指出对象类型的信息

3.type_info结构存储了特定类型的信息

注意：只能将RTTI用于包含虚函数的类层次结构，原因在于只有对于这种类层次，才应该将派生类对象的地址赋给基类指针。

警告：RTTI只适用于包含虚函数的类。

dynamic_cast运算符

在C++中，dynamic_cast是一种运行时类型检查和转换的操作符，用于在继承体系中进行安全的向下转型。它的语法如下：

dynamic_cast<目标类型>(表达式)

其中，目标类型是你想要将表达式转换为的类型，表达式是需要转换的对象。

dynamic_cast的使用有以下几个要点：

  1. dynamic_cast只能在具有多态性（即包含虚函数的类）的类之间进行类型转换。（is-a关系里可用）

  2. dynamic_cast会在运行时检查目标类型是否与表达式的类型兼容，如果不兼容则返回nullptr（对于指针类型）或抛出std::bad_cast异常（对于引用类型）。因此，在使用dynamic_cast时应该先判断转换结果是否为nullptr（空指针）或捕获异常。

  3. dynamic_cast只能用于指针或引用类型的转换。对于指针类型，如果转换失败，则返回nullptr；对于引用类型，如果转换失败，则抛出std::bad_cast异常。

下面是一个使用dynamic_cast的示例：

#include<iostream>
using namespace std;
class Base {
public:virtual void foo() {cout << "Base::foo()" << endl;}
};class Derived : public Base {
public:void foo() {cout << "Derived::foo()" << endl;}
};int main() {//用基类指针创建派生类对象Base* basePtr = new Derived();//将基类指针强制转换为派生类对象Derived* derivedPtr = dynamic_cast<Derived*>(basePtr);//判断是否转换成功if (derivedPtr!=nullptr) {derivedPtr->foo();  // 输出 "Derived::foo()"}else {cout << "dynamic_cast failed!" << endl;}delete basePtr;  // 记得释放内存return 0;
}

运行结果

Derived::foo()

 在上面的示例中，由于Derived是Base的派生类，我们可以将Derived类型的对象的地址赋给Base指针。然后，通过使用dynamic_cast将Base指针转换为Derived指针，我们可以调用Derived类的成员函数。

我们看个反面例子

#include<iostream>
using namespace std;
class Base {
public:virtual void foo() {cout << "Base::foo()" << endl;}
};class Derived : public Base {
public:void foo() {cout << "Derived::foo()" << endl;}
};int main() {//用基类指针创建基类对象Base* basePtr = new Base();//将基类指针强制转换为派生类指针Derived* derivedPtr = dynamic_cast<Derived*>(basePtr);//判断是否转换成功if (derivedPtr!=nullptr) {derivedPtr->foo();  // 输出 "Derived::foo()"}else {cout << "dynamic_cast failed!" << endl;}delete basePtr;  // 记得释放内存return 0;
}

 运行结果

dynamic_cast failed

 在上面的示例中，由于Derived是Base的派生类，发现不能安全的将指向基类地址的指针赋给派生类指针，所以derivedPtr被dynamic_cast赋予了空指针。

需要注意的是，如果Base类中没有声明为虚函数的成员函数，那么dynamic_cast无法进行类型转换。在这种情况下，可以考虑使用static_cast(我们等会会讲）进行类型转换，但这样做是不安全的，因为static_cast不会进行运行时类型检查。

typeid运算符和type_info类

在C++中，typeid运算符用于获取表达式的类型信息。它的语法如下：

typeid(表达式)

其中，表达式可以是任意类型的对象、类名、变量或者表达式。

注意包含头文件<typeinfo>

typeid运算符的使用有以下几个要点：

  1. typeid运算符返回一个std::type_info对象，它包含了类型的信息，可以用于比较两个类型是否相同。

  2. typeid运算符可以用于动态类型识别，即在运行时判断对象的实际类型。

  3. typeid运算符只能用于具有多态性（即包含虚函数的类）的类。

  4. typeid运算符对指针和引用类型的表达式进行操作时，返回的是指针或引用所指向的对象的类型信息。

下面是一个使用typeid的示例：

#include <typeinfo>
#include <iostream>class Base {
public:virtual void foo() {}
};class Derived : public Base {};int main() {Base* basePtr = new Derived();std::cout << typeid(*basePtr).name() << std::endl;  // 输出 "class Derived"Base& baseRef = *basePtr;std::cout << typeid(baseRef).name() << std::endl;  // 输出 "class Derived"delete basePtr;  // 记得释放内存return 0;
}

运行结果

class Derived
class Derived

在上面的示例中，我们创建了一个Base指针指向Derived对象，并通过typeid运算符获取了该对象的类型信息。可以看到，typeid运算符返回的是一个std::type_info对象，使用其name()方法可以获取类型的名称。

需要注意的是，typeid运算符返回的类型名称可能是编译器特定的名称，所以并不是在所有编译器中都能得到相同的结果。此外，typeid运算符还可以用于比较两个类型是否相同（使用==运算符进行比较），以及在异常处理中判断对象的类型。

typeid(a)==typeid(b)

判断a，b的类型是否相同

类型转换运算符

我们先看看之前的强制转换

int a=(int)3.0;
char b=char(888.0);

这些强制转换真的安全吗？

肯定不安全啊

为此，C++引入了4个类型转换运算符：dynamic_cast，const_cast，static_cast，reinterpret_cast

dynamic_cast

我们在上面已经讲了这个的用法，这个运算符的用途是能使得在类结构层次中进行向上转换（只能在is-a关系），而不允许其他转换

什么？你不知道is-a关系？看这里http://t.csdnimg.cn/JUgEI

const_cast

const_cast能将常量对象转换为非常量对象。

const_cast的语法如下：

const_cast<type>(expression)

其中，type表示要转换的类型，expression表示要转换的表达式。

使用const_cast需要注意以下几点：

性质一

在C++中，const_cast只能改变运算对象的底层const

情况1

如果expression是个常量，则使用const_cast来企图修改这个常量，这会产生未定义的后果

	const int num = 10;int* ptr = const_cast<int*>(&num);  // 将const int*转换为int**ptr = 20;  // 企图修改num的值cout << num << endl;

我们去运行一下就会发现

结果不是20！！因为企图修改常量，这是未定义的后果

我们再看一个例子

	const char* pc;char* p = const_cast<char*>(pc);char a = 'A';p = &a;cout << *pc << endl;

我们拿去运行，结果居然是

显然我们并没有成功修改常量

情况2

如果expression是个变量，则使用const_cast来获取修改权限的行为是允许的 

	int a = 1;int* ptr = &a;const int* const_ptr = ptr;int* non_const_ptr = const_cast<int*>(const_ptr);  // 将const int*转换为int**non_const_ptr = 30;  // 修改了a的值cout << *ptr << endl;

 

显然我们修改成功了

性质二

只有const_cast能改变表达式的常量属性，使用其他的命名强制类型转变表达式的常量属性都将引发编译器错误。同样的，也不能使用const_cast改变表达式的类型

const char* cp;
char* q = static_cast<char*>(cp);
//这是不允许的，只有const_cast能改变表达式的常量属性
string a=const_cast<string>(cp);
//这是不允许的，const_cast只改变表达式的类型

static_cast

这个可能是我们最常用的类型转换运算符

在C++中，static_cast类型转换的运算符。任何具有明确定义的类型转化，只要不包含底层const，都可以使用static_cast将一个类型转换为另一个相关的类型

如将整数类型转换为浮点类型，指针类型与整数类型之间的转换等。

static_cast的语法如下：

static_cast<type>(expression)

其中，type表示要转换的目标类型，expression表示要转换的表达式。

使用

我们先看个例子

当需要把一个较大的算术类型赋值给较小的类型时，我们先来看看普通的做法

	double a = 9.00;int b = a;cout << b << endl;

这样子运行起来确实没什么问题

但编译器会提醒

 

我们可以通过static_cast来实现

    double a = 9.00;int b = static_cast<int>(a);cout << b << endl;

我们发现编译器不报错了 

这是因为，此时，强制类型转换告诉程序的读者和编译器：我们知道并且不在乎潜在的精度损失。一般来说，如果编译器发现一个较大的算术类型试图赋值给较小的类型，就会给出警告信息；但是当我们执行了显式的类型转换后，警告信息就会被关闭了。


static_cast对于编译器无法自动执行的类型转换也非常有用。

例如，我们可以使用static cast 找回存在于void*指针中的值：
 

double d=9.0;
void* p= &d; // 正确：任何非常量对象的地址都能存入void* d为doable类
//正确：将void*转换回初始的指针类型
double *dp = static_cast<double*>(p);


当我们把指针存放在void*中，并且使用static_cast 将其强制转换回原来的类型时，应该确保指针的值保持不变。也就是说，强制转换的结果将与原始的地址值相等，因此我们必须确保转换后所得的类型就是指针所指的类型。类型一旦不符，将产生未定义的后果。

double d=9.0;
void* p= &d; 
int *dp = static_cast<int*>(p);
//这的结果是未定义的

下面是一些使用static_cast的例子：

int num = 10;
double d = static_cast<double>(num);  // 将int转换为doubleint a = 100;
void* void_ptr = static_cast<void*>(&a);  // 将int*转换为void*class Base {};
class Derived : public Base {};
Base* base_ptr = new Derived();
Derived* derived_ptr = static_cast<Derived*>(base_ptr);  // 将Base*转换为Derived*

在上面的例子中，我们分别使用了static_cast将整数类型、指针类型和引用类型进行了转换。注意最后一个例子中的指针类型转换，它只能在具有继承关系的类型之间进行转换，并且只能在相互兼容的类型之间进行转换。

reinterpret_cast

这个可能是最不常使用的类型转换运算符

reinterpret_cast可以执行任意类型之间的转换，即使类型之间没有任何关系

reinterpret_cast的语法如下：

reinterpret_cast<type>(expression)

其中，type表示要转换的目标类型，expression表示要转换的表达式。

使用reinterpret_cast需要注意以下几点：

  1. reinterpret_cast可以执行任意类型之间的转换，即使类型之间没有任何关系。

  2. reinterpret_cast不进行类型检查或安全检查，因此在使用时需要非常小心。

  3. reinterpret_cast通常用于需要底层二进制表示或将指针转换为整数类型的场景。

危险示例 

我们看个例子

int a=10;
int*b=&a;
char*c=reinterpret_cast<char*>(b);
string str(c);

使用reinterpret_cast是非常危险的，用c初始化str的例子很好地证明了这一点。

其中的关键问题是类型改变了，但编译器没有给出任何警告或者错误的提示信息。

当我们用一个int的地址初始化c时，由于显式地声称这种转换合法，所以编译器不会发出任何警告或错误信息。

接下来再使用c时就会认定它的值是char*类型，编译器没法知道它实际存放的是指向int的指针。

最终的结果就是，在上面的例子中虽然用c初始化str 没什么实际意义，甚至还可能引发更糟糕的后果，但仅从语法上而言这种操作无可指摘。

查找这类问题的原因非常困难，如果将b强制转换成c的语句和用c初始化string对象的语句分属不同文件就更是如此。 

下面是一些使用reinterpret_cast的例子：

int num = 42;
char* char_ptr = reinterpret_cast<char*>(&num);  // 将int*转换为char*int* num_ptr = reinterpret_cast<int*>(char_ptr);  // 将char*转换为int*int i = 10;
int* iptr = reinterpret_cast<int*>(&i);  // 将int转换为int*class A {};
class B {};
A* a_ptr = new A();
B* b_ptr = reinterpret_cast<B*>(a_ptr);  // 将A*转换为B*

上面的例子中，我们分别使用了reinterpret_cast将不同类型的指针进行了转换。注意在第一个例子中，我们将int指针转换为char指针，并且reinterpret_cast没有进行任何类型检查，因此需要非常小心使用。

旧式的强制类型转换

在早期版本的C++语言中，显式地进行强制类型转换包含两种形式：

type (expr); // 函数形式的强制类型转换
(type) expr; // C语言风格的强制类型转换

建议：避免强制类型转换

强制类型转换干扰了正常的类型检查，因此我们强烈建议程序员避免使用强制类型转换。

这个建议对于reinterpret_cast尤其适用，因为此类类型转换总是充满了风险。

在有重载函数的上下文中使用const_cast无可厚非；但是在其他情况下使用 const_cast也就意味着程序存在某种设计缺陷。

其他强制类型转换，比如 static_cast和dynamic_cast，都不应该频繁使用。每次书写了一条强制类型转换语句，都应该反复斟酌能否以其他方式实现相同的目标。就算实在无法避免，也应该尽量限制类型转换制的作用域，并且记录对相关类型的所有假定，这样可以减少错误发生的机会。

这篇关于掘根宝典之C++RTTI和类型转换运算符的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/824185。

相关文章

C++ Primer 标准库vector示例详解

C++ Primer 标准库vector示例详解

《C++Primer标准库vector示例详解》该文章主要介绍了C++标准库中的vector类型,包括其定义、初始化、成员函数以及常见操作,文章详细解释了如何使用vector来存储和操作对象集合,... 目录3.3标准库Vector定义和初始化vector对象通列表初始化vector对象创建指定数量的元素值
阅读更多...
C++实现回文串判断的两种高效方法

C++实现回文串判断的两种高效方法

《C++实现回文串判断的两种高效方法》文章介绍了两种判断回文串的方法：解法一通过创建新字符串来处理,解法二在原字符串上直接筛选判断,两种方法都使用了双指针法,文中通过代码示例讲解的非常详细,需要的朋友... 目录一、问题描述示例二、解法一：将字母数字连接到新的 string思路代码实现代码解释复杂度分析三、
阅读更多...
C++一个数组赋值给另一个数组方式

C++一个数组赋值给另一个数组方式

《C++一个数组赋值给另一个数组方式》文章介绍了三种在C++中将一个数组赋值给另一个数组的方法：使用循环逐个元素赋值、使用标准库函数std::copy或std::memcpy以及使用标准库容器,每种方... 目录C++一个数组赋值给另一个数组循环遍历赋值使用标准库中的函数 std::copy 或 std::
阅读更多...
C++使用栈实现括号匹配的代码详解

C++使用栈实现括号匹配的代码详解

《C++使用栈实现括号匹配的代码详解》在编程中,括号匹配是一个常见问题,尤其是在处理数学表达式、编译器解析等任务时,栈是一种非常适合处理此类问题的数据结构,能够精确地管理括号的匹配问题,本文将通过C+... 目录引言问题描述代码讲解代码解析栈的状态表示测试总结引言在编程中，括号匹配是一个常见问题，尤其是在
阅读更多...
使用C++实现链表元素的反转

使用C++实现链表元素的反转

《使用C++实现链表元素的反转》反转链表是链表操作中一个经典的问题,也是面试中常见的考题,本文将从思路到实现一步步地讲解如何实现链表的反转,帮助初学者理解这一操作,我们将使用C++代码演示具体实现,同... 目录问题定义思路分析代码实现带头节点的链表代码讲解其他实现方式时间和空间复杂度分析总结问题定义给定
阅读更多...
C++初始化数组的几种常见方法(简单易懂)

C++初始化数组的几种常见方法(简单易懂)

《C++初始化数组的几种常见方法(简单易懂)》本文介绍了C++中数组的初始化方法,包括一维数组和二维数组的初始化,以及用new动态初始化数组,在C++11及以上版本中,还提供了使用std::array... 目录1、初始化一维数组1.1、使用列表初始化（推荐方式）1.2、初始化部分列表1.3、使用std::
阅读更多...
C++ Primer 多维数组的使用

C++ Primer 多维数组的使用

《C++Primer多维数组的使用》本文主要介绍了多维数组在C++语言中的定义、初始化、下标引用以及使用范围for语句处理多维数组的方法,具有一定的参考价值,感兴趣的可以了解一下... 目录多维数组多维数组的初始化多维数组的下标引用使用范围for语句处理多维数组指针和多维数组多维数组严格来说,C++语言没
阅读更多...
c++中std::placeholders的使用方法

c++中std::placeholders的使用方法

《c++中std::placeholders的使用方法》std::placeholders是C++标准库中的一个工具,用于在函数对象绑定时创建占位符,本文就来详细的介绍一下,具有一定的参考价值,感兴... 目录1. 基本概念2. 使用场景3. 示例示例 1：部分参数绑定示例 2：参数重排序4. 注意事项5.
阅读更多...
使用C++将处理后的信号保存为PNG和TIFF格式

使用C++将处理后的信号保存为PNG和TIFF格式

《使用C++将处理后的信号保存为PNG和TIFF格式》在信号处理领域,我们常常需要将处理结果以图像的形式保存下来,方便后续分析和展示,C++提供了多种库来处理图像数据,本文将介绍如何使用stb_ima... 目录1. PNG格式保存使用stb_imagephp_write库1.1 安装和包含库1.2 代码解
阅读更多...
C++实现封装的顺序表的操作与实践

C++实现封装的顺序表的操作与实践

《C++实现封装的顺序表的操作与实践》在程序设计中,顺序表是一种常见的线性数据结构,通常用于存储具有固定顺序的元素,与链表不同,顺序表中的元素是连续存储的,因此访问速度较快,但插入和删除操作的效率可能... 目录一、顺序表的基本概念二、顺序表类的设计1. 顺序表类的成员变量2. 构造函数和析构函数三、顺序表
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2