C++进阶（二）四种类型转换（static_cast, const_cast, dynamic_cast, reinterpret_cast）

最新推荐文章于 2024-05-13 16:44:16 发布
最新推荐文章于 2024-05-13 16:44:16 发布
阅读量287 收藏 3
点赞数 1
分类专栏： C++进阶 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DreamRE/article/details/112154764
版权

C++进阶（二）四种类型转换（static_cast, const_cast, dynamic_cast, reinterpret_cast）

   在 C 语言中，如果要对类型进行转换，直接使用强制类型转换。这种转换使得表达式的精度有所损失，会出现一些未定义错误。这种强制转换方式有如下缺点：

  • 任何类型都能进行强制转换，编译器很难判断其正确性
  • 在源码中，无法定位所有强制类型转换的语句
(Type) (expression);
Type(expression);

  C++中提出4种安全可靠的类型转换方式：static_cast，const_cast，dynamic_cast，reinterpret_cast 。下面来分别介绍每种类型转换的应用场景及用法。
 

static_cast 类型转换

  static_cast 是一种静态类型转换，用于基本类型转换，但不能用于基本类型指针之间的转换。也可用于继承关系的类对象的转换和类指针之间的转换。

示例1：基本类型之间的转换

#include <iostream> 
using namespace std; 
int main() 
{ 
	float f = 3.5; 
	int a = f; 			// C 中隐式类型转换
	int b = static_cast<int>(f); 	// C++ 中强制类型转换
	cout << b << endl; 
}

编译执行，浮点型变量转换为 整型。
float2int

示例2：static_cast 不能用于指针之间的类型转换

#include <iostream>
using namespace std;

int main(){
	int i = 0x123456;
	char c = 'c';
	int* pi = &i;
	char* pc = &c;
	
	c = static_cast<char>(i);
	pc = static_cast<char*>(pi);		// 无法在指针类型间进行转换
	return 0;
}

编译出错，无法将 int* 转换为 char* 类型。
static_cast
  注释掉指针类型后，编译执行即可通过，下面再看下从int 类型强制转换为 char 类型，编译器如何转换。
int2char

示例3：类中定义类型转换函数（operator Type()）


#include <iostream>
#include <string>
using namespace std;
class Int {
    int x;

public:
    Int(int x_in = 0)
            : x{ x_in }
    {
        cout << "Conversion Ctor called" << endl;
    }
    // C++ 中类型转换函数
    operator string()
    {
        cout << "Conversion Operator" << endl;
        return to_string(x);
    }
};
int main()
{
    Int obj(3);             // Int 对象，调用构造函数
	
	// Int -> string 对象 ，相当于 string str = obj.string(obj)
    string str = obj;       
    // 隐式类型转换，20 --> Int(20)，调用构造函数
    obj = 20;               
	
	// Int -> string 对象，相当于string str2 = obj.string(obj)
    string str2 = static_cast<string>(obj);     
    // 显示强制类型转换， 30 --> Int(30)，调用构造函数
    obj = static_cast<Int>(30);    
    return 0;
}

编译运行，输出如下：

Conversion Ctor called
Conversion Operator
Conversion Ctor called
Conversion Operator
Conversion Ctor called

  
示例4：继承关系的类对象之间的转换，基类指针指向父类对象

#include <iostream> 
using namespace std; 
class Base { 
}; 
class Derived : public Base { 	// 必须为public 继承，才能进行强制类型转换
}; 
int main() 
{ 
	Derived d1; 
	Base* b1 = (Base*)(&d1); 				// C语言中强制类型转换
	Base* b2 = static_cast<Base*>(&d1); 	// C++ 中强制类型转换

	return 0; 
}

编译指向，可以看到使用 static_cast 类型转换符将基类指针指向子类对象。
base->Derived

 

const_cast 类型转换

  const_cast 用于去除变量的只读属性，强制转换的目标类型是指针或引用。

示例一：在 const 成员函数中修改类中 non-const 成员变量。

#include <iostream> 
using namespace std; 

class student 
{ 
private: 
	int roll; 
public: 
	// constructor 
	student(int r):roll(r) {} 

	// A const function that changes roll with the help of const_cast 
	void fun() const
	{ 
		( const_cast <student*> (this) )->roll = 5; 
	} 

	int getRoll() { return roll; } 
}; 

int main(void) 
{ 
	student s(3); 
	cout << "Old roll number: " << s.getRoll() << endl; 

	s.fun(); 

	cout << "New roll number: " << s.getRoll() << endl; 

	return 0; 
}

编译运行结果如下：

Old roll number: 3
New roll number: 5

  在const 成员函数中，将this 指针修改为 const Student* const ，使用 const_cast 强制类型转换，使得const Student* const 修改为 Student* const ，所以可以修改 Student对象。

示例2：将常量指针强制转换为普通指针

int fun(int* ptr)
{
    return (*ptr + 10);
}

int main(void)
{
    const int val = 10;
    const int *ptr = &val;
    int *ptr1 = const_cast <int *>(ptr);		// 转换为普通指针，作为参数传递
    cout << fun(ptr1);
    return 0;
}

示例3：const_cast 将指向const对象的指针进行强制类型转换，会产生未定义行为。


#include <iostream> 
using namespace std; 

int fun(int* ptr) 
{ 
	*ptr = *ptr + 10; 
	return (*ptr); 
} 

int main(void) 
{ 
	const int val = 10; 
	const int *ptr = &val; 					// const指针指向const变量
	int *ptr1 = const_cast <int *>(ptr); 	// 未定义行为，将const指针的const属性去掉，会使得普通指针指向常量，此时通过指针修改常量，产生未定义行为
	fun(ptr1); 
	cout << val; 
	return 0; 
}

程序可以编译运行，但是会输出10。因为在指向常量值，常量值无法改变。

示例4：const_cast 类型安全，无法在不同的类型之间进行转换

#include <iostream> 
using namespace std; 

int main(void) 
{ 
	int a1 = 40; 
	const int* b1 = &a1; 
	char* c1 = const_cast <char *> (b1); // 编译失败，无法将int * 转换为 char *
	*c1 = 'A'; 
	return 0; 
}

示例5：const_cast 可以将 volatile 类型转化为非 volatitle 类型

#include <iostream> 
#include <typeinfo> 
using namespace std; 

int main(void) 
{ 
	int a1 = 40; 
	const volatile int* b1 = &a1; 
	cout << "typeid of b1 " << typeid(b1).name() << '\n'; 
	int* c1 = const_cast <int *> (b1); 
	cout << "typeid of c1 " << typeid(c1).name() << '\n'; 
	return 0; 
}

编译输出

typeid of b1 PVKi		// Pointer to a volatile and constant integer
typeid of c1 Pi				// Pointer to integer

 

reinterpret_cast 类型转换

  reinterpret_cast 用于指针类型之间的类型转换，也用于整数与指针之间的类型转换。用法如下

data_type *var_name = 
       reinterpret_cast <data_type *>(pointer_variable);

示例1：指针类型转换（将int* 强制转换为 char*）

// CPP program to demonstrate working of 
// reinterpret_cast 
#include <iostream> 
using namespace std; 

int main() 
{ 
	int* p = new int(65); 
	char* ch = reinterpret_cast<char*>(p); 
	cout << *p << endl; 
	cout << *ch << endl; 
	cout << p << endl; 
	cout << ch << endl; 
	return 0; 
}

编译输出，将int* 转换为 char* ，输出字符A

65		// 原始数值
A			// 将int* 转换为 char*，65 --> A
0xf31c90	// 输出地址
A			// 输出字符

示例2：类之间的强制类型转换

// CPP code to illustrate the pointer reinterpret 
#include <iostream> 
using namespace std; 

class A { 
public: 
	void fun_a() 
	{ 
		cout << " In class A\n"; 
	} 
}; 

class B { 
public: 
	void fun_b() 
	{ 
		cout << " In class B\n"; 
	} 
}; 

int main() 
{ 
	// creating object of class B 
	B* x = new B(); 

	// converting the pointer to object 
	// referenced of class B to class A 
	A* new_a = reinterpret_cast<A*>(x); 

	// accessing the function of class A 
	new_a->fun_a(); 
	return 0; 
}

编译输出，得到

In class A

 

dynamic_cast 类型转换

   dynamic_cast 只能虚函数的类使用，用于具有继承关系的类之间的类型转换；也用于有交叉关系的类指针的类型转换。dynamic_cast 可以进行类型检查。

 

巨人的肩膀

  1. C++中static_cast 类型转换
  2. C++中 const_cast 类型转换
  3. C++中 reinterpret_cast 类型转换

一键三连是对我的最大支持与鼓励。欢迎关注编程小镇，每天涨一点新姿势😄。

编程小镇
关注
专栏目录
C++类型转换运算符dynamic_cast、static_cast 和 reinterpret_cast
啊渊的专栏
04-19 914
和。这些转换运算符可以用来在不同的上下文中进行类型转换，但它们的行为和使用场景是不同的。
C++学习笔记（一）
Yuhang1997_Recall的博客
04-02 240
Chapter 1 开始集成开发环境IDE 从命令行运行编译器：$ cc prog1.ccCC是编译器程序的名字，$是系统提示符 IO（输入输出）机制：iostream库——istream（输入流）和ostream（输出流）istream——cin（标准输入）ostream——cour（标准输出）此外还有cerr（输出错误和警告信息）clog（输出程序运行时一般信息） std::cout &lt;...
【C++】C++学习笔记
xifan的博客
07-03 6320
所谓数组，就是一个集合，里面存放了相同类型的数据元素特点1：数组中的每个==数据元素都是相同的数据类型==**特点2：**数组是由==连续的内存==位置组成的数据类型 数组名[ 数组长度 ];数据类型 数组名[ 数组长度 ] = { 值1，值2 ...};数据类型 数组名[ ] = { 值1，值2 ...};示例//定义方式1//数据类型 数组名[元素个数];//利用下标赋值//利用下标输出//第二种定义方式。
C++中的类型转换static_cast、dynamic_cast、const_cast和reinterpret_cast总结
09-04
本文将详细介绍四种主要的显式类型转换：`static_cast`、`dynamic_cast`、`const_cast`和`reinterpret_cast`。 首先，`static_cast`主要用于非多态类型的转换，它不提供运行时的类型检查。例如，当进行基类与子类...
static_cast,dynamic_cast,reinterpret_cast,const_cast的区别及用法详解
12-31
2.dynamic_cast提供安全的转换如果两个指针不存在继承关系转换会失败返回空指针，如果你提供一个错误的指针那样会发生内存访问异常，因为它会去比较两个类型的虚函数表。虚函数表的指针一般放在对象指针最开始的四字...
c++自考题目的整理
weixin_44698281的博客
11-26 410
1、对象数组 定义：所谓对象数组，指每一个数组元素都是对象的数组，即若一个类有若干个对象，我们把这一系列的对象用一个数组来存放。对象数组的元素是对象，不仅具有数据成员，而且还有函数成员。 定义一个一维数组的格式如下： 类名 数组名[下标表达式] 与基本数据类型的数组一样，在使用对象数组时也只能访问单个数组元素，其一般形式为： 数组名[下标].成员名 在建立数组时，同样要调用构造函数。有几个...
C++编程理论学习笔记（一）
weixin_30483495的博客
03-16 125
1.变量 变量的值都存储在内存中。内存中每个单元都有一个唯一的编号，就是单元的地址，变量在运行时占据内存单元互不相同的地址，C++的目标代码靠地址来区别不同的变量。 2.表达式： 虽然内存是存储c++变量的主要场所，但不可能一切读写操作都通过在内存中进行，事实上，CPU的大部分读写操作都是对寄存器进行的。 寄存器从内存中取得变量值，存储每一步运算的中间结果，最后返回给表达式。 3.函数调...
【C++学习笔记】
最新发布
gpb2714446205的博客
05-13 519
C++总计63个关键字，C语言32个关键字随着学习的深入，各个关键字都会使用到。
c++学习笔记（一）
qq_45279235的博客
05-29 116
目录c++的产生和发展C++的特点C++能够处理的基本数据类型C风格字符串常量逗号运算和逗号表达式逻辑运算与逻辑表达式位运算一一移位(<<、>>) c++的产生和发展 从c语言发展演变而来，最初被称为“带类的C”，他最初尽可能的继承兼容C语言的所有语法，在这个基础上对类提供了支持。 C++的特点 兼容C，支持面向过程的程序设计 支持面向对象的方法 支持泛型程序设计方法 #include <iostream> using namespace std; int main(){
C++ 学习笔记
weixin_42074992的博客
06-14 117
一. 存储类：1.auto: auto 关键字用于两种情况：声明变量时根据初始化表达式自动推断该变量的类型、声明函数时函数返回值的占位符。'''auto f=3.14; //doubleauto s("hello"); //const char*auto z = new auto(9); // int*auto x1 = 5, x2 = 5.0, x3='r';//错误，必须是初始化为...
c++ 学习笔记
折花刀的博客
01-11 1504
1，引用在声明时必须初始化。 2，所有对象共享同一个静态常量——c++ primer plus 第五版 p327，10.8之前 3，关于const常量总结——http://blog.csdn.net/Eric_Jo/article/details/4138548#0-qzone-1-83534-d020d2d2a4e8d1a374a433f596ad1440 4，不能定义unsigned dou...
C++学习笔记
qq_43875428的博客
09-08 174
三、想使用其他.cpp文件的函数或变量，最好不用#include".cpp"这样容易报多定义错误(multiple definition of)。应当用#include".h"的方式。 四、指针指向结构体时，访问其成员变量用 ->符号；结构体变量访问成员变量用 . 符号。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值