【C++】类型转换

樊梓慕

于 2024-07-28 10:07:30 发布

阅读量459

点赞数 15

分类专栏： C++ 文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/2301_77112634/article/details/138678893

版权

C++ 专栏收录该内容

35 篇文章 3 订阅

订阅专栏

👀樊梓慕：个人主页

🎥个人专栏：《C语言》《数据结构》《蓝桥杯试题》《LeetCode刷题笔记》《实训项目》《C++》《Linux》《算法》

🌝每一个不曾起舞的日子，都是对生命的辜负

前言

本篇文章我们会从C语言的类型转换策略入手，剖析C语言类型转换的优点缺点，并且对于这些特性C++又是如何处理的？

欢迎大家📂收藏📂以便未来做题时可以快速找到思路，巧妙的方法可以事半功倍。

=========================================================================

GITEE相关代码：🌟樊飞 (fanfei_c) - Gitee.com🌟

=========================================================================

1.C语言中的类型转换

C语言和C++都是强类型语言，如果赋值运算符左右两侧变量的类型不同，或形参与实参的类型不匹配，或返回值类型与接收返回值的变量类型不一致，那么就需要进行类型转换。

C语言中总共有两种形式的类型转换：隐式类型转换与显式类型转换。

隐式类型转换：编译器在编译阶段自动进行，能转就转，不能转就编译失败。
显式类型转换：需要用户自己处理，以『（类型）变量』的方式进行类型转换。

注意：C语言中，有一定关联的类型才可以进行类型转换，比如整型家族（隐式类型转换），指针和整型（显示类型转换），指针是地址（字节编号也可以理解为是一种大小，所以和整型之间也可以认为有关系），但是如果没关系就无法转换，比如浮点型和指针。

void Test()
{
	int i = 1;
	// 隐式类型转换
	double d = i;
	printf("%d, %.2f\n", i, d);
	int* p = &i;
	// 显示的强制类型转换
	int address = (int)p;
	printf("%x, %d\n", p, address);
}

但是C语言的类型转换有着很明显的缺点：

隐式类型转化有些情况下可能会出问题：比如数据精度丢失。
显式类型转换将所有情况混合在一起，代码不够清晰。

2.C++类型转换

因此C++为了加强类型转换的可视性，引入了四种命名的强制类型转换操作符，分别是static_cast、reinterpret_cast、const_cast和dynamic_cast。

2.1static_cast

static_cast相当于C语言中的隐式类型转换，既然是隐式类型转换，那么就只能用于相近类型的转换。

int main()
{
	double d = 12.34;
	int a = static_cast<int>(d);
	cout << a << endl;

	int* p = &a;
	// int address = static_cast<int>(p); //error 无关类型
	return 0;
}

2.2reinterpret_cast

reinterpret_cast相当于C语言中的强制类型转换，可以用于不相关类型的转换。

int main()
{
	double d = 12.34;
	int a = static_cast<int>(d);
	cout << a << endl;
	// 这里使用static_cast会报错，应该使用reinterpret_cast
	//int *p = static_cast<int*>(a);
	int* p = reinterpret_cast<int*>(a);
	return 0;
}

2.3const_cast

const_cast用于删除变量的const属性，转换后就可以对const变量的值进行修改。比如：

void Test ()
{
    const int a = 2;
    int* p = const_cast< int*>(&a);
    *p = 3; //去除了const属性，可以修改
    cout<<a<<endl; //2  为什么？
    cout<<*p<endl; //3
}

当编译器识别到a是一个const变量时，那么编译器就会认为该变量不会被修改，就将该变量放置到寄存器中存储一份，目的是为了提升读取效率，但这里如果我们通过const_cast删除了const属性，内存中存储的a就会被改变，所以我们打印*p，即a的地址的内容当然已经发生了改变，但是打印a，实际上这里取得是寄存器中的值，所以你会发现打印a的值还是2。

那么为了解决这一问题，我们要保证每次取值都要去内存中取，而不是编译器优化的结果，所以我们要加入volatile关键字，该关键字确保内存可见性，要求每次取值都要到内存中取。

void Test ()
{
    volatile const int a = 2;
    int* p = const_cast< int*>(&a);
    *p = 3; //去除了const属性，可以修改
    cout<<a<<endl; //3
    cout<<*p<endl; //3
}

2.4dynamic_cast

dynamic_cast用于将父类的指针（或引用）转换成子类的指针（或引用）。

向上转型： 子类的指针（或引用）→ 父类的指针（或引用）。
向下转型： 父类的指针（或引用）→ 子类的指针（或引用）。

其中，向上转型就是我们所说的切割/切片，这部分不需要进行转换，而向下转型是语法不支持的，需要进行强制类型转换。

而向下转型又分为两种情况：

如果父类的指针（或引用）指向的是一个父类对象，那么将其转换为子类的指针（或引用）是不安全的，因为转换后可能会访问到子类的资源，而这个资源是父类对象所没有的。
如果父类的指针（或引用）指向的是一个子类对象（多态前提），那么将其转换为子类的指针（或引用）则是安全的。

如果父类的指针（或引用）指向的是子类对象那么dynamic_cast会转换成功，但如果父类的指针（或引用）指向的是父类对象，那么dynamic_cast会转换失败并返回一个空指针。

实例：

class A
{
public:
	virtual void f()
	{}
};
class B : public A
{};
void func(A* pa)
{
	B* pb1 = (B*)pa;               //不安全，可能越界访问
	B* pb2 = dynamic_cast<B*>(pa); //安全，如果越界，转换失败返回空

	cout << "pb1: " << pb1 << endl;
	cout << "pb2: " << pb2 << endl;
}
int main()
{
	A a;
	B b;
	func(&a); //父类地址
	func(&b); //子类地址
	return 0;
}

上述代码中，如果传入func函数的是子类对象的地址，那么在转换后pb1和pb2都会有对应的地址，但如果传入func函数的是父类对象的地址，那么转换后pb1会有对应的地址，而pb2则是一个空指针。

所以dynamic_cast实际上就是为了确保如果发生越界访问，此时该指针置空，通过这样的方式，确保我们使用的地址是安全的。