目录
C语言中的类型转换
C++中的类型转换
C++中的类型转换操作符
static_cast
reinterpret_cast
const_cast
volatile关键字
赋值兼容
dynamic_cast
C语言中的类型转换
基本概念:赋值运算符左右两侧类型不同,或形参与实参类型不匹配,或者返回值类型与接收返回值类型不一致时,需要发生类项转换,C语言中有两种形式的类型转换,隐式类型转换和显示类型转换
注意事项:有关联的类型才可以相互转换,小类型会转换为大类型
- 整型之间的隐转(int、long、short)
- 整型和浮点数间的隐转
- 整型和字符型间的隐转
- bool和整型、指针间的隐转(整数0和空指针均表示假)
- 整型和指针间的强转(地址的本质是一个编号所以可以)
//整型转换为指针
//缺点:在绝大多数情况下是不安全的,除非你确切知道这个整数表示的内存地址是有效的
int number = 1234;
int *ptr = (int *)number;//指针转换为整型:通常用于获取指针的内存地址
//缺点:如果在64位系统上,将指针转换为32位整数(如 int),可能会导致数据丢失。因此,建议使用 intptr_t 或 uintptr_t 类型,它们在 <stdint.h> 头文件中定义,可以确保适当的大小来存储指针值
int *ptr = &number;
int address = (int)ptr;
关于intptr_t和uintptr_t可以查看:intptr_t、uintptr_t数据类型的解析
- 不同类型的指针间的强转
//不同类型的指针间的强制类型转换
char s = 'a';
char* ptr1 = &s;
int* ptr2 = (int*) ptr1;
显示类型转换的缺点:
- 可能导致数据丢失:当从一个较大的数据类型转换为一个较小的数据类型时,可能会丢失数据。例如,将 double 转换为 int 时,小数部分会被截断
double d = 3.14; int i = (int)d; // i = 3, 小数部分丢失
- 降低代码可读性:频繁使用显式类型转换会使代码变得难以阅读和理解,尤其是当类型转换逻辑复杂时
float f = (float)((int)doubleValue * 2.0);
- 增加错误风险:进行类型转换时,容易忽略一些潜在的错误,如溢出或数据精度问题,导致难以发现的bug
long longValue = 1234567890123456789LL;
int intValue = (int)longValue; // 可能会溢出
隐式类型转换的缺点:
-
隐蔽的数据丢失:将
int
转换为float
时,如果整数的值超过了浮点数的精度范围,可能会丢失精度
int i = 123456789; float f = i; // 可能会丢失精度
-
难以调试和维护:隐式类型转换发生在幕后,可能导致意外的结果和难以调试的问题。出错时需要仔细检查代码,以确保所有隐式转换都符合预期
//int被转换为size_t,当传入的pos = 0时,会陷入死循环
void Insert(size_t pos)
{int end = 10;// 比较的时候end会隐式类型转换成size_t,再比较while (end >= pos){cout << end << "挪走" << endl;--end;}
}
C++中的类型转换
基本概念:C++中通过构造函数和重载可以实现内置类型与自定义类型间、自定义类型间的转换
- 内置类型->自定义类型:借助构造函数,隐式类型转换
//单参数的构造函数,支持内置类型隐式转换成自定义类型
string s1 = "111111";
const string& s2 = "11111";
- 自定义类型->内置类型:重载某个类型(operator +类型名)
class A
{
public:operator int(){return _a1 + _a2;}
private:int _a1 = 1;int _a2 = 2;
};int main()
{A aa;int a = aa;int b = (int)aa;cout << a << endl;cout << b << endl;return 0;
}
- 自定义类型->自定义类型:借助构造函数进行隐式类型转换(initializer_list和容器间)
C++中的类型转换操作符
基本概念:C++依然兼容C语言的两种类型转换方式,但是为了加强类型转换时的可视性,C++引入了四种类型转换操作符,它们是一些进行类型转换时的命名建议,并不强制
static_cast
基本概念:进行有关联的类型间的隐式类型转换(编译时进行,也叫静态转换)
int main()
{//C++的隐式类型转换:明显double d = 12.34;int a1 = static_cast<int>(d);cout << a1 << endl;//12//C语言的隐式类型转换:不明显int a2 = d;cout << a2 << endl;//12return 0;
}
reinterpret_cast
音标:riːɪnˈtɜːrprət
基本概念:进行强制类型转换,不进行类型检查
int main()
{int a = 12;// int* p = static_cast<int*>(a); 报错,int和int*不是两个相关的类型int* p = reinterpret_cast<int*>(a);cout << p << endl;return 0;
}
const_cast
基本概念:删除对象的const属性
int main()
{const int a = 10;int* p = const_cast<int*>(&a); // 去除const属性*p = 20; // 尝试修改值cout << a << endl;//a == 10cout << *p << endl;//*p == 20return 0;
}
对比监视列表和控制台,可以发现虽然在内存中a的值变为了20,但是打印时a仍为原来的10,这是因为编译器知道const修饰的变量不会被修改,那么编译器在编译阶段就会对其优化,即编译器会将常量的值直接内联到使用该常量的地方,而不是每次都访问内存中的存储位置,这一优化技术称为“常量折叠”或“常量传播”
补充:const修饰的局部变量仍然存放在栈上,修饰的全局变量才放在常量区中
volatile关键字
基本概念:用于指示编译器不对变量进行优化(带入上述代码再试一试即可)
volatile const int a = 10;//表示不会对a进行优化
结论:const_cast和reinterpret_cast都是强制类型转换(const_cast的第一个例子中的a去掉const修饰也能const_cast也能正常使用,且a打印时也为20),但是单独将const_cast拿出来就是因为可能出现因为编译器对const修饰的变量进行优化而导致的内存可见性
赋值兼容
基本概念:有继承关系的派生类与基类之间所遵循的赋值规则,包括向上和向下转型
- 向上转型:派生类对象赋值给基类对象(发生切片,切片 != 类型转换)、派生类的指针/引用赋值给基类的指针/引用(通常情况下都支持)(即这两种情况正常情况下都是可以支持的)
#include <iostream>
using namespace std;class A
{};class B : public A
{};int main()
{//向上转型B bb;A aa = bb;//派生类对象直接赋值给基类对象,发生切片A* ptr = &bb;//派生类对象的指针可以直接赋值给基类对象的指针B& cc = bb;A& str = cc;//派生类对象的引用可以直接赋值给基类对象的引用return 0;
}
- 向下转型:基类对象赋值给派生类对象(除非有相关的构造函数、否则即使是强转也转不了)、基类对象的指针/引用赋值给派生类对象的指针/引用(可以通过强转实现,但有越界风险需要得到控制)
//有相应的构造函数才能实现基类对象到派生类对象间的转换
#include <iostream>
using namespace std;class A {
public:int baseData;A() : baseData(0) {}A(int data) : baseData(data) {}
};class B : public A {
public:B() {};// 自定义构造函数,实现基类到派生类的转换B(const A& a) : A(a) {cout << "hello" << endl;}// 自定义赋值运算符,实现基类到派生类的转换B& operator=(const A& a) {cout << "world" << endl;return *this;}
};int main() {A aaa(10);B bbb;bbb = aaa; // 使用自定义赋值运算符B bbb2 = aaa; // 使用自定义构造函数return 0;
}
dynamic_cast
基本概念:为了能控制向下转型时的越界问题、C++提供了dynamic_cast类型转换操作符,dynamic_cast会在转换前检查是否能转换成功,可以转换就转换、不能转换就返回0
#include <iostream>
using namespace std;class A
{
public:virtual void f() {}int _a = 0;
};class B : public A
{
public:int _b = 1;
};void fun(A* pa)
{// 向下转换:父->子// pa指向子类对象,转回子类,是安全的// pa指向父类对象,转回子类,是不安全的,存在越界的风险问题// 不安全//B* pb = (B*)pa;// pa指向子类对象,转回子类,正常转换// pa指向父类对象,转回子类,转换失败B* pb = dynamic_cast<B*>(pa);if (pb){cout << pb << endl;cout << pb->_a << endl;cout << pb->_b << endl;}else{cout << "转换失败" << endl;}
}int main()
{A a;B b;fun(&a);//父类转为子类fun(&b);//子类转为子类return 0;
}
注意事项:dynamic_cast在使用时,基类要有虚函数(有就行)
~over~