C++ 强制类型转换：从 C 风格到 C++ 四大金刚

强制类型转换是很多 C++ 程序员心里的一个疙瘩。从 C 带过来的 (int)x 看似方便，但在复杂的 C++ 继承体系、多态场景下，它就像一把没有保险的枪------你不知道它到底做了什么，也不知道会不会走火。

C++11 引入了四种命名强制转换运算符，不是为了增加复杂度，而是为了让意图更明确、代码更安全、排查更容易。今天我们就彻底搞懂它们。

1. 为啥要摒弃 C 风格的强制转换？

C 风格的写法是这样的：

double d = 3.14;
int i = (int)d;   // C 风格
int j = int(d);   // 函数风格，等价于上面

这看起来简单，但问题很大：

• 不明确 ：(int*)ptr 到底是去掉 const？是基类转派生类？还是把整数硬当指针？一个括号什么都干了，你不知道它背后是哪种转换语义。
• 难排查：代码出问题时，满屏的括号让你无法快速 grep 出所有转换点。
• 不安全 ：它可以做最暴力的 reinterpret_cast，编译器几乎不会阻止你做任何蠢事。

const int a = 10;
int* p = (int*)&a;  // 编译通过，悄悄去掉了 const
*p = 20;            // 未定义行为！

C++ 给出的解决方案：四种命名的转换运算符，每个都有明确职责。

2. static_cast：编译时类型检查的"正常"转换

2.1 能做什么？

static_cast 处理的是相关类型之间的"合理"转换，在编译时进行类型检查。

// 基本类型的标准转换
double d = 3.14;
int i = static_cast<int>(d);  // 截断小数，等价于隐式转换

// 派生类指针/引用 -> 基类指针/引用（上行转换，安全）
Derived* derived = new Derived();
Base* base = static_cast<Base*>(derived);  // 一定安全

// void* -> 具体类型指针
void* vp = &i;
int* ip = static_cast<int*>(vp);  // 从 void* 转回原始类型

2.2 不能做什么？

• 不能去掉 const（那是 const_cast 的活）
• 不能做完全不相关类型之间的转换（比如 int* 转 double*）
• 不能做基类到派生类的安全下行转换（当涉及多态时应该用 dynamic_cast）

int* p = &i;
// double* dp = static_cast<double*>(p);  // 编译错误！不相关的类型

注意 ：static_cast 可以用于基类到派生类的下行转换，但不做运行时安全检查。如果指针实际不指向那个派生类对象，结果是未定义的。

Base* b = new Base();
Derived* d = static_cast<Derived*>(b);  // 编译通过，但危险！b 实际不是 Derived

2.3 什么时候用？

大多数"正常"的显式类型转换都用 static_cast：

• 基本类型转换（代替 (int)x）
• 上行转换（派生类转基类）
• void* 的恢复
• 调用窄化转换时显式表明意图

3. dynamic_cast：运行时安全检查的多态转换

dynamic_cast 专门用于继承层次中的下行转换，并且要求在运行时进行类型检查。

3.1 必要条件

• 类必须有虚函数（即类是多态的），因为运行时类型信息（RTTI）依赖虚函数表。
• 转换发生在指针或引用上。

3.2 指针版本：失败返回 nullptr

class Base { virtual void foo() {} };
class Derived : public Base {};

Base* b = new Derived();
Derived* d = dynamic_cast<Derived*>(b);  // 成功，b 实际指向 Derived
if (d != nullptr) {
    // 安全使用 d
}

Base* b2 = new Base();
Derived* d2 = dynamic_cast<Derived*>(b2);  // 失败！返回 nullptr

模式 ：dynamic_cast 后必须判空，这是标准写法。

3.3 引用版本：失败抛出 std::bad_cast

Derived& rd = dynamic_cast<Derived&>(*b2);  // b2 是 Base，抛出 std::bad_cast

try {
    Derived& rd = dynamic_cast<Derived&>(someRef);
} catch (std::bad_cast& e) {
    // 处理失败
}

3.4 也能做交叉转换

dynamic_cast 还能处理多重继承中的交叉转换（从一个基类转换到另一个基类），这是 static_cast 做不到的。

3.5 什么时候用？

• 你必须将一个基类指针/引用转换为派生类指针/引用，但不确定它是否真的指向派生类对象时。
• 多重继承中需要安全地进行交叉转换。

性能提醒 ：dynamic_cast 有运行时开销（类型信息查找），不要滥用。如果能确定类型，用 static_cast 更快。

4. const_cast：唯一的去/加 const 工具

const_cast 只能做一件事：添加或移除 const（和 volatile）属性。

4.1 基本用法

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

int* p = const_cast<int*>(cp);  // 去掉 const
*p = 20;  // 注意！如果 a 本身是 const，这是未定义行为

4.2 安全的用法场景

什么时候用 const_cast 是正当的？

场景一：兼容老旧的 C API

// 某 C 库函数，参数不是 const，但你知道它不会修改字符串
void old_c_function(char* str);

std::string myStr = "hello";
old_c_function(const_cast<char*>(myStr.c_str()));  
// 你确定这个函数只读，安全

场景二：消除重复代码

class Text {
    std::string content;
public:
    const char& operator[](size_t pos) const {
        // 大量边界检查逻辑...
        return content[pos];
    }

    char& operator[](size_t pos) {
        // 不想重复写检查逻辑，可以复用 const 版本
        return const_cast<char&>(
            static_cast<const Text&>(*this)[pos]
        );
    }
};

这个模式很经典：非 const 版本调用 const 版本，然后用 const_cast 去掉返回的 const，避免代码重复。注意不要反过来 ，const 版本调用非 const 版本是危险的。

4.3 什么时候不能用？

const int a = 10;   // a 是真正的 const 对象
const_cast<int&>(a) = 20;  // 未定义行为！a 可能放在只读内存区

规则 ：如果原对象本身不是 const，只是通过 const 指针/引用来访问它，const_cast 去掉 const 后修改是安全的。如果原对象就是 const，修改它会导致未定义行为。

5. reinterpret_cast：最危险的转换，接近汇编

reinterpret_cast 是最底层的转换，它直接把一段内存的二进制位重新解释为另一种类型。不进行任何类型检查，不调整内存布局，不做任何转换。

5.1 基本用法

// 整数和指针互转
int a = 10;
int* p = &a;
uintptr_t addr = reinterpret_cast<uintptr_t>(p);  // 指针转整数
int* p2 = reinterpret_cast<int*>(addr);            // 整数转回指针

// 完全不相关类型的指针互转
struct A { int x; };
struct B { int y; };
A a;
B* bp = reinterpret_cast<B*>(&a);  // 把 A 当 B 用，极危险

5.2 什么时候用？

正常业务代码中几乎不应该出现 reinterpret_cast。它主要出现在：

• 底层系统编程：与硬件寄存器交互、内存映射 I/O
• 网络编程：序列化/反序列化原始字节
• 哈希函数：将对象指针转成整数以计算哈希
• 某些特定优化的内存对齐操作

5.3 一个大坑：错误地用在多重继承

class Base1 { int x; };
class Base2 { int y; };
class Derived : public Base1, public Base2 {};

Derived d;
Base2* b2_static = static_cast<Base2*>(&d);     // 正确，编译器自动调整偏移
Base2* b2_reinterpret = reinterpret_cast<Base2*>(&d); // 危险！不调整偏移，指针值可能错误

当涉及多重继承时，基类子对象在派生类对象中的地址可能不是起始地址。static_cast 会自动计算并调整偏移，而 reinterpret_cast 不会。用 reinterpret_cast 代替 static_cast 做下行转换，得到的是一个可能完全错误的指针。

6. 四种转换一览表

转换运算符	用途	检查时机	安全性	常见场景
static_cast	相关类型之间的合理转换	编译时	较安全	基本类型转换、上行转换、void* 恢复
dynamic_cast	多态类型的下行安全转换	运行时	安全（返回 null/抛异常）	基类转派生类（不确定实际类型时）
const_cast	添加/移除 const 属性	编译时	有限安全	兼容老 API、减少代码重复
reinterpret_cast	二进制位重新解释	编译时	极危险	底层系统编程、指针/整数互转

7. 面试常考清单

7.1 C++ 的四种强制转换分别是什么？各自的使用场景是什么？

答案要点：参见上表，需要能一一说出名字、作用、特点。

7.2 dynamic_cast 在什么情况下返回 nullptr？什么情况下抛异常？

答案要点：

• 指针版本：转换失败返回 nullptr
• 引用版本：转换失败抛出 std::bad_cast 异常

7.3 为什么 dynamic_cast 要求类必须有虚函数？

答案要点 ：dynamic_cast 依赖运行时类型信息（RTTI），RTTI 是通过虚函数表（vtable）存储的。没有虚函数的类没有 vtable，无法在运行时确定对象的真实类型。

7.4 什么情况下 const_cast 修改 const 对象是安全的？

答案要点 ：当原对象本身不是 const，只是通过 const 指针/引用间接访问时，用 const_cast 去掉 const 后修改是安全的。如果原对象本身就是 const（定义时就是 const），修改它是未定义行为。

7.5 为什么在多重继承中不能随便用 reinterpret_cast 做基类转换？

答案要点 ：多重继承时，多个基类子对象在派生类内存布局中的偏移不同。static_cast 会自动计算偏移，reinterpret_cast 不调整指针值，会导致指针指向错误位置。

7.6 C 风格强制转换在 C++ 中的等价行为是什么？

答案要点 ：C 风格转换 (T)expr 按照以下顺序尝试：

1. const_cast
2. static_cast（加上可能隐含的 const_cast）
3. static_cast + const_cast
4. reinterpret_cast
5. reinterpret_cast + const_cast

它会选择第一个能编译通过的组合，意味着一次 C 风格转换可能偷偷做了 const_cast + reinterpret_cast 这种最危险的组合。

8. 实践指南

1. 默认用 static_cast 做显式类型转换，它是最安全的"正常"转换。
2. 多态下行用 dynamic_cast，并且记得判空。
3. 去 const 才用 const_cast，并且确保原始对象可修改。
4. 除非写底层代码，否则不用 reinterpret_cast。
5. 不要写 C 风格转换，它让你失去编译器的保护。