掘根宝典之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++ vector的常见用法超详细讲解

C++ vector的常见用法超详细讲解

《C++vector的常见用法超详细讲解》：本文主要介绍C++vector的常见用法,包括C++中vector容器的定义、初始化方法、访问元素、常用函数及其时间复杂度,通过代码介绍的非常详细,... 目录1、vector的定义2、vector常用初始化方法1、使编程用花括号直接赋值2、使用圆括号赋值3、ve
阅读更多...
如何高效移除C++关联容器中的元素

如何高效移除C++关联容器中的元素

《如何高效移除C++关联容器中的元素》关联容器和顺序容器有着很大不同,关联容器中的元素是按照关键字来保存和访问的,而顺序容器中的元素是按它们在容器中的位置来顺序保存和访问的,本文介绍了如何高效移除C+... 目录一、简介二、移除给定位置的元素三、移除与特定键值等价的元素四、移除满足特android定条件的元
阅读更多...
Python获取C++中返回的char*字段的两种思路

Python获取C++中返回的char*字段的两种思路

《Python获取C++中返回的char*字段的两种思路》有时候需要获取C++函数中返回来的不定长的char*字符串,本文小编为大家找到了两种解决问题的思路,感兴趣的小伙伴可以跟随小编一起学习一下... 有时候需要获取C++函数中返回来的不定长的char*字符串，目前我找到两种解决问题的思路，具体实现如下：
阅读更多...
C++ Sort函数使用场景分析

C++ Sort函数使用场景分析

《C++Sort函数使用场景分析》sort函数是algorithm库下的一个函数,sort函数是不稳定的,即大小相同的元素在排序后相对顺序可能发生改变,如果某些场景需要保持相同元素间的相对顺序,可使... 目录C++ Sort函数详解一、sort函数调用的两种方式二、sort函数使用场景三、sort函数排序
阅读更多...
Java调用C++动态库超详细步骤讲解(附源码)

Java调用C++动态库超详细步骤讲解(附源码)

《Java调用C++动态库超详细步骤讲解(附源码)》C语言因其高效和接近硬件的特性,时常会被用在性能要求较高或者需要直接操作硬件的场合,：本文主要介绍Java调用C++动态库的相关资料,文中通过代... 目录一、直接调用C++库第一步：动态库生成（vs2017+qt5.12.10）第二步：Java调用C++
阅读更多...
C/C++错误信息处理的常见方法及函数

C/C++错误信息处理的常见方法及函数

《C/C++错误信息处理的常见方法及函数》C/C++是两种广泛使用的编程语言,特别是在系统编程、嵌入式开发以及高性能计算领域,：本文主要介绍C/C++错误信息处理的常见方法及函数,文中通过代码介绍... 目录前言1. errno 和 perror()示例：2. strerror()示例：3. perror(
阅读更多...
C++变换迭代器使用方法小结

C++变换迭代器使用方法小结

《C++变换迭代器使用方法小结》本文主要介绍了C++变换迭代器使用方法小结,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧... 目录1、源码2、代码解析代码解析：transform_iterator1. transform_iterat
阅读更多...
详解C++中类的大小决定因数

详解C++中类的大小决定因数

《详解C++中类的大小决定因数》类的大小受多个因素影响,主要包括成员变量、对齐方式、继承关系、虚函数表等,下面就来介绍一下,具有一定的参考价值,感兴趣的可以了解一下... 目录1. 非静态数据成员示例：2. 数据对齐（Padding）示例：3. 虚函数（vtable 指针）示例：4. 继承普通继承虚继承5.
阅读更多...
C++中std::distance使用方法示例

C++中std::distance使用方法示例

《C++中std::distance使用方法示例》std::distance是C++标准库中的一个函数,用于计算两个迭代器之间的距离,本文主要介绍了C++中std::distance使用方法示例,具... 目录语法使用方式解释示例输出：其他说明：总结std::distance&n编程bsp;是 C++ 标准
阅读更多...
C++ 中的 if-constexpr语法和作用

C++ 中的 if-constexpr语法和作用

《C++中的if-constexpr语法和作用》if-constexpr语法是C++17引入的新语法特性,也被称为常量if表达式或静态if（staticif）,：本文主要介绍C++中的if-c... 目录1 if-constexpr 语法1.1 基本语法1.2 扩展说明1.2.1 条件表达式1.2.2 fa
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2