C++ 显式类型转换详解：四种 Cast 用法对比

• 任意指针之间互转（int* → double*）
• 指针 → 整数（uintptr_t） → 指针
• 将一块内存按另一种类型解释（'类型重解释'）

✔ 特性

• 底层二进制不变，只改变解释方式
• 没有安全检查
• 很容易造成未定义行为（UB）
• 多用于：
  • 底层系统编程（驱动、内核代码）
  • 内存池
  • 自己写序列化
  • 跨语言 / 跨库的 API

int i = 0x11223344;
char* p = reinterpret_cast<char*>(&i); // 获取字节级别内容
long addr = reinterpret_cast<long>(p); // 指针 <-> 整数

❌ 错误风险

double* dp = reinterpret_cast<double*>(p);
double x = *dp; // 未定义行为！因为内存不是 double 布局

一句话总结：

reinterpret_cast 是'霸王硬上弓'，能做任何转换，但你必须保证安全性。

3. const_cast —— 唯一能修改 const 属性的转换

✔ 用途

• 去掉 const
• 去掉 volatile
• 添加 const（极少用这个）

✔ 特性

• 只能改变对象的 const / volatile 修饰，不改变类型本身
• 必须非常小心：移除 const 后修改对象 → 未定义行为（UB）

✔ 示例：去掉 const

void f(const int* p) {
    int* q = const_cast<int*>(p);
    *q = 10; // ⚠ 若 p 原本指向的是 const 对象，UB！
}

所以 const_cast 只有一个真正安全的用途：

当你知道对象原本不是 const，只是接口要求参数是 const 时。

比如 API：

void foo(const int* x) {
    int* p = const_cast<int*>(x); // 只要你保证 x 指向的不是 const 对象
}

一句话总结：

const_cast 专门用来处理'去 const'的场景，不做类型转换。

4. dynamic_cast —— 多态体系中的安全向下转型

✔ 用途

• 子类 / 父类之间安全的类型转换
• 只能用于 带虚函数（有 RTTI） 的类层次结构

✔ 向下转型（Parent → Child）

Parent* p = new Child();
Child* c = dynamic_cast<Child*>(p); // OK

✔ 失败时会返回 nullptr（指针版本）

Parent* p = new Parent();
Child* c = dynamic_cast<Child*>(p); // c == nullptr，安全！

✔ 运行时检查（RTTI）

• 会查对象的实际类型
• 是唯一一个带'运行时成本'的 cast

✔ 引用版本失败会抛异常

Parent p;
Child& c = dynamic_cast<Child&>(p); // throws std::bad_cast

一句话总结：

dynamic_cast 是唯一'真正安全'的向下转型方式，用于多态。

重点区分 static_cast 和 reinterpret_cast

🟦 static_cast —— 语义转换，真正变成新的类型

✔ static_cast 会做'逻辑正确的'类型转换

• int → double（改变值，类型变了）
• Derived* → Base*（安全的向上转型）
• void* → T*（但你保证原本就是 T）

✔ static_cast 会让变量成为目标类型（有意义的转换）

例如：

int i = 42;
double d = static_cast<double>(i); // d == 42.0

这里：

• 内存重新组织（int → double）
• 表示的数据类型改变
• 语义上是新值

再比如：

Derived* d;
Base* b = static_cast<Base*>(d);

这里：

• 类型系统认可
• 行为可预测
• 对象仍然属于 Derived，只是你看它'是个 Base 指针'

static_cast 永远不会破坏对象布局，是安全的语义转换。

🟥 reinterpret_cast —— 不改变内存，只改变解释方式

✔ 它不会'改变类型'，只是'改变阅读器'

想象你拿一本书（内存）：

• static_cast：把内容按照需求重新排版成新书
• reinterpret_cast：不改内容，换一副不同的眼镜（把文字当成别的语言看）

int x = 0x11223344;
char* p = reinterpret_cast<char*>(&x);

内存布局：

44 33 22 11 (在小端序机器上)

你只是 用 char 的方式读它的内容，而不是把 int 转成 char。

再看危险例子：

int* ip = new int(10);
double* dp = reinterpret_cast<double*>(ip);
double d = *dp; // ❌ 未定义行为

原因：

• 你告诉编译器：'这块 int 的内存，是 double！'
• 但布局完全不对，因此读取是错误的

✔ reinterpret_cast 的本质：

内存原样不动，只改变你访问它时使用的类型。

二者区别可以用一句话记住

• static_cast：转换 = 合理的，编译器帮你确保安全
• reinterpret_cast：转换 = 你说了算，后果自负