C++的四种类型转换

int a = 10;
double b = static_cast<double>(a); // 合法：int→double
enum class color {blue, red};
int a = static_cast<int> (Color::blue);  // a = 0;
int b = static_cast<int> (Color::red);  // b = 1;

⭐void 指针与其他类型指针之间的转换。

class Animal {};
class Dog : public Animal {};
Dog * dog = new Dog;
void* void_ptr = static_cast<void*>(dog); // 转成 void 指针

⭐类层次结构中，上行转换
（派生类指针/引用 -> 基类指针/引用）。这个是安全的。

class Animal {};
class Dog : public Animal {};
Dog dog;
Animal* ptr = static_cast<Animal*>(&dog); // 合法：上行转换

⚠️风险：
不支持父子类的下行转换（基类→派生类），强制转换会得到错误指针（编译不报错，但运行时访问可能崩溃）。

class Animal { virtual ~Animal() = default; }; // 多态类（含虚函数）
class Dog : public Animal {};

// 错误用法
Animal * a_ptr1 = new Animal;
Dog * d_ptr1 = static_cast<Dog *> (a_ptr1); // / 错误做法：类型不对将导致 UB

// 正确用法：
Animal* a_ptr2 = new Dog(); // 基类指针指向派生类对象
// 下行转换：运行时检查a_ptr指向的对象是否为Dog类型
Dog* d_ptr = dynamic_cast<Derived*>(a_ptr); 
if (d_ptr != nullptr) { // 检查转换是否成功
    // 合法访问Dog成员
}

说明：

上行转换（派生类→基类）总是安全而且可以隐式转换；

下行转换（基类→派生类）只有当对象的真实类型是该派生类时才是安全的。

static_cast：下行转换不会做运行期的检查，类型不对将导致未定义行为（UB）
dynamic_cast：需要基类必须含有虚函数，指针转换失败会返回nullptr，引用转换失败会抛出异常std::bad_cast

至于什么时候使用哪一个：

已经可以证明对象的真实类型是Dog（就比如该对象是通过Dog的构造函数实例化的）（还是以上面的代码说明），这个时候就可以使用static_cast进行下行转换
无法确定对象的真实类型或者来自多态接口：使用 dynamic_cast并检查结果。

⚠️注意：static_cast不可以用于在不同类型的指针之间互相转换，也不能用于整型等其他类型（如float）与指针类型的转换，当然也不能用于不同类型引用的转换。

比如：

int age = 10;
// int* p = static_cast<int*>(age); 
// error C2440: “static_cast”: 无法从“int”转换为“int *”

int* p = &age;
// double* d_ptr = static_cast<double*> (p);
// error C2440: “static_cast”: 无法从“int *”转换为“double *”

// 但是可以通过void * 进行转换
void* tmp = static_cast<void*> (p);
double* d_ptr = static_cast<double*> (tmp);

✨二、动态转换（dynamic_cast）：运行时的 “精准安全” 转换

专门用于处理含虚函数的继承体系中的安全下行转换和交叉转换。它是唯一在运行时进行类型检查的转换。

⭐主要用途：

安全的下行转换：将基类指针/引用转换为派生类指针/引用。
交叉转换：在同一继承层次中，从一个分支转到另一个分支。

⭐1、依赖虚函数表的底层逻辑

只有包含虚函数的类（也叫多态类）才会生成虚函数表，对象中会有虚表指针（vptr）指向该表。dynamic_cast通过 vptr 找到虚函数表，再从表中获取信息，判断对象实际类型是否与目标转换类型匹配。

class Animal {
public:
	virtual ~Animal() {} // 必须有虚函数
};

class Dog : public Animal {};
Animal* a_ptr = new Dog;
// 运行时流程：
// 1. 通过b_ptr获取对象的vptr；
// 2. 从vptr指向的vtable中读取类型信息（确认是Dog）；
// 3. 类型匹配，返回Dog*指针
Dog* d_ptr = dynamic_cast<Dog*>(b_ptr);

非多态类（无虚函数）无 vtable 和 vptr，无法提供运行时类型信息，因此dynamic_cast直接编译报错，避免无依据的转换。

class Base { void func() {} }; // 无虚函数
class Derived : public Base {};

Base* b_ptr = new Derived();
// 编译报错：Base不是多态类，无运行时类型信息
Derived* d_ptr = dynamic_cast<cDerived*>(b_ptr);

⭐2、不同转换目标的结果差异（也就是指针和引用的类型转换）

1️⃣指针类型转换：失败时返回nullptr，可通过判空明确处理失败场景，是最常用的方式。

Base* b1_ptr = new Base();
// 运行时检查：b1_ptr指向Base对象，与Derived不匹配，返回nullptr
Derived* d1_ptr = dynamic_cast<Derived*>(b1_ptr); 
if (d1_ptr == nullptr) {
    std::cout << "转换失败：对象实际类型为Base" << std::endl;
}

2️⃣引用类型转换：引用无法为nullptr，因此失败时抛出std::bad_cast异常，需用try-catch捕获处理，避免程序崩溃。

Base b2;
Base& b2_ref = b2;
try {
    // 运行时检查：b2_ref绑定Base对象，转换失败
    Derived& d2_ref = dynamic_cast<Derived&>(b2_ref); 
} catch (const std::bad_cast& e) {
    // 捕获异常，输出错误信息（如"Bad dynamic_cast"）
    std::cout << "转换失败：" << e.what() << std::endl;
}

⭐3、多继承中的交叉转换场景

在多继承中，派生类同时继承多个基类，此时可通过dynamic_cast将一个基类指针转换为另一个基类指针，前提是对象实际类型为派生类。

class BaseA { virtual void ~BaseA() {} };
class BaseB { virtual void ~BaseB() {} };
class Derived : public BaseA, public BaseB {};

Derived* d_ptr = new Derived();
BaseA* a_ptr = d_ptr; // 上行转换：BaseA*指向Derived对象
// 交叉转换：通过BaseA*转换为BaseB*，运行时检查对象实际为Derived，转换成功
BaseB* b_ptr = dynamic_cast<BaseB*>(a_ptr); 
if (b_ptr != nullptr) {

}

⭐注意：

运行时检查：如果转换目标不匹配（例如，基类对象不是目标派生类对象），对于指针，返回 nullptr；对于引用，抛出 std::bad_cast 异常。
要求多态：基类必须至少有一个虚函数（否则编译报错）。
有性能开销：因为需要查询运行时类型信息（RTTI）。

✨三、常量转换（const_cast）：仅修改 “常量属性” 的精准工具

const_cast的功能高度专一，仅能修改const或volatile属性，不可以改变类型，但是需要严格区分 “顶层 const” 与 “底层 const”，避免踩坑。

⭐主要用途：

移除 const/volatile：用于调用非 const 版本的旧 API，但这些 API 不会修改对象。
增加 const/volatile：将一个对象变为只读。

⭐1、顶层 const 与底层 const 的核心区别

1️⃣顶层 const：const 修饰整个变量，变量本身不可修改（内存中数据不可变），常见于const int a = 5、int* const ptr = &a（指针本身不可变）。

对顶层 const 变量使用const_cast移除 const 后修改，会导致未定义行为（程序崩溃、数据错乱或看似正常）。

#include <iostream>

int main() {
	const int a = 10;
	int* p = const_cast<int*> (&a);

	std::cout << "a的地址: " << &a << std::endl;
	std::cout << "p的地址: " << p << std::endl;

	std::cout << "修改前 a = " << a << std::endl;        
	std::cout << "修改前 *p = " << *p << std::endl;     

	*p = 20;  // 未定义行为！

	std::cout << "修改后 a = " << a << std::endl;    
	std::cout << "修改后 *p = " << *p << std::endl;    

	std::cout << "&a == p: " << (&a == p) << std::endl;  

	return 0;
}

⁉️可能的输出结果（让人困惑的情况）：

a的地址: 0019F7F8
p的地址: 0019F7F8
修改前 a = 10
修改前 *p = 10
修改后 a = 10      ← a 的值没变！
修改后 *p = 20     ← 但 *p 的值变了！
&a == p: 1         ← 确实是同一个地址！

❓️为什么会这样？

这是因为编译器的优化行为：

编译期常量传播：编译器看到 const int a = 10，知道 a 是常量，在编译时就把所有直接使用 a 的地方替换为字面量 10。
内存实际可能被修改：*p = 20 确实修改了内存，但编译器生成的代码中，std::cout << a 被优化为 std::cout << 10，根本不会去读取内存。

⚠️⚠️⚠️更危险的后果

在不同的编译环境或优化级别下，还可能出现：

⚠️程序崩溃（如果 a 被放在只读内存页）
⚠️数据不一致导致的其他逻辑错误
⚠️难以调试的随机行为

✅️正确的做法：

#include <iostream>
int main() {
    int original = 10;
    const int& a = original;  // 通过引用添加 const，但原始对象是可变的
    int* p = const_cast<int*>(&a);  // 这时是安全的，因为原始对象不是 const
    *p = 20;
    std::cout << "a = " << a << std::endl;     // 输出 20
    std::cout << "*p = " << *p << std::endl;   // 输出 20
    return 0;
}

2️⃣底层 const：const 修饰指针 / 引用指向的内容，变量本身（指针 / 引用）可修改，但指向的内容不可修改，如 const int * a。

对底层 const 的指针 / 引用使用const_cast移除 const 后，若指向的实际变量是非 const 的，修改是安全的。

int num = 30; // 非const变量
const int* const_ptr = &num; // 底层const：指向内容不可修改
// 移除底层const：ptr指向的实际变量是非const的，修改安全
int* modify_ptr = const_cast<int*>(const_ptr); 
*modify_ptr = 40; // 安全：num的值变为40
std::cout << num << std::endl; // 输出40

⭐2、仅支持指针、引用与成员指针

const_cast仅能作用于指针、引用或类的成员指针，无法直接转换普通变量或其他类型，否则编译报错

const int a = 10;
const int* const_ptr = &a;

// 合法：移除指针的const属性
int* non_const_ptr = const_cast<int*>(const_ptr);
// *non_const_ptr = 20; // 运行时未定义行为，但编译通过

class MyClass {
public:
    int value;
};

const int MyClass::* const_mem_ptr = &MyClass::value;
// 合法：移除成员指针的const属性
int MyClass::* non_const_mem_ptr = const_cast<int MyClass::*>(const_mem_ptr);

⭐特点：

非常危险：用它来修改一个原本就是 const的对象，会导致未定义行为。
用途有限：通常只在“我知道这个对象不是真正的常量，但接口要求非 const”时使用。

✨四、重新解释转换（reinterpret_cast）：底层 “暴力” 转换的风险与场景

这是最底层、最不安全的转换。它简单地按照比特位模式，将一种类型重新解释为另一种类型，不进行任何数据格式的检查或转换。

⭐主要用途：

指针与指针之间的转换。
指针与整数之间的转换。
在不同类型的函数指针之间转换。

⭐1、指针类型转换的底层逻辑

转换时直接将指针的二进制值视为目标指针类型的二进制值，不改变指针存储的地址，仅改变编译器对地址的 “类型解读”，可能导致访问方式与内存布局不匹配。

int x = 0x12345678; 
// 假设为小端平台（低字节存低地址），内存布局：0x78 0x56 0x34 0x12
// 将int*转为char*：char*仅指向1字节，解读为0x78（ASCII值对应的字符）
char* char_ptr = reinterpret_cast<char*>(&x); 
std::cout << static_cast<int>(*char_ptr) << std::endl; // 输出120（0x78的十进制）

// 风险：若强制转为更大类型的指针，访问会越界
long long* ll_ptr = reinterpret_cast<long long*>(&x);
// 运行时错误：ll_ptr指向8字节，但x仅占4字节，访问后4字节为非法内存
std::cout << *ll_ptr << std::endl;

⭐2、指针与整数类型转换的规范场景

仅推荐与uintptr_t（无符号整数类型，大小与指针一致）转换，用于存储指针的数值（如日志记录、哈希表存储指针），避免与普通整数类型（如int、long）转换（可能因指针大小与整数大小不匹配导致数据丢失）。

int* ptr = new int(100);
// 规范转换：uintptr_t大小与指针一致，无数据丢失
uintptr_t ptr_val = reinterpret_cast<uintptr_t>(ptr); 
std::cout << "指针数值：" << ptr_val << std::endl; // 输出指针的十六进制地址对应的整数

// 风险：int可能为4字节，64位平台指针为8字节，转换会丢失高位数据
int ptr_int = reinterpret_cast<int>(ptr); 
std::cout << ptr_int << std::endl; // 输出不完整的指针数值（高位丢失）

⭐3、绝对禁止的转换场景

禁止用于普通数值类型转换（如int→double），两种类型的内存存储规则完全不同（int为补码，double为符号位 + 指数位 + 尾数位），转换后数值无意义。

int num = 10;
// 编译通过，但结果无意义：将int的二进制视为double的二进制
double wrong_double = *reinterpret_cast<double*>(&num); 
std::cout << wrong_double << std::endl; // 输出极小的随机数（非10.0）

⭐特点：

极其不安全：不提供任何类型安全保证。
不可移植：转换结果可能因平台、编译器而异。

✨五、四种转换的对比总结与避坑指南

转换类型	底层依赖	核心避坑点	典型正确场景	典型错误场景
static_cast	编译期语法规则	禁止基类指针 / 引用向下转为派生类（除非确认指向派生类对象）	int→double、派生类→基类	纯基类对象→派生类指针
dynamic_cast	运行时虚函数表类型信息	仅用于多态类，引用转换需捕获 std::bad_cast 异常	基类指针→派生类指针（判空）	非多态类转换、引用转换不处理异常
const_cast	仅修改 const 属性标记	不修改顶层 const 变量，不转换普通变量，仅作用于指针 / 引用 / 成员指针	底层 const 指针→非 const 指针（指向非 const 变量）	顶层 const 变量→非 const 指针并修改
reinterpret_cast	内存二进制位直接解读	仅与 uintptr_t 转换，不用于普通类型转换，不跨平台使用	指针→uintptr_t（日志记录）	int→double、指针→不匹配类型指针（如 int→long long）