摘要 :C 语言的
(类型)变量写起来爽,但意图模糊、编译期无法校验风险。C++ 用四个"带名字"的转换把意图写在代码里------static_cast管常规转换、dynamic_cast管多态安全向下转型、const_cast只管 const/volatile、reinterpret_cast负责底层比特重解释。本文从语法、适用场景、典型坑、面试考点四个维度一次讲透,附完整可运行 Demo。
适合人群 :C++ 入门到进阶、准备面试、想读懂开源代码里那些static_cast的同学。
目录
- [一、为什么 C++ 要"发明"四种转换](#一、为什么 C++ 要"发明"四种转换)
- 二、static_cast:日常主力
- 三、dynamic_cast:多态体系下的安全向下转型
- [四、const_cast:只动 const,不动类型](#四、const_cast:只动 const,不动类型)
- 五、reinterpret_cast:二进制重解释,慎用
- 六、四种转换对比表
- 七、选型口诀
- 八、常见面试考点
- [九、完整 Demo(可直接运行)](#九、完整 Demo(可直接运行))
- 十、几个容易踩的坑
- 十一、总结
一、为什么 C++ 要"发明"四种转换
C 语言只有一种写法:
c
double d = 3.14;
int i = (int)d; // C 风格强转
它的问题有三个:
- 意图不明确 。同样是
(T)x,可能是数值截断、可能是去掉 const、可能是把指针当整数用,读代码的人完全看不出你想干什么。 - 编译器无法检查风险。C 风格强转几乎"能转就转",把本该报错的代码放过去了。
- 搜索困难 。想在几万行代码里找出所有强转点?
(加类型名这种模式根本没法 grep。
C++ 于是引入了四个命名式转换,把"为什么转"这件事显式化:
| 转换 | 一句话定位 |
|---|---|
static_cast |
编译期认可的"合理转换" |
dynamic_cast |
运行时检查的"安全向下转型" |
const_cast |
只增删 const / volatile |
reinterpret_cast |
按二进制原样重新解释 |
核心原则:优先使用 C++ 四种命名转换,尽量不用 C 风格强转。
因为 C 风格强转在标准里的定义是"按顺序尝试":const_cast → static_cast → static_cast + const_cast → reinterpret_cast → reinterpret_cast + const_cast。也就是说,它同时具备四种转换的能力,还顺手把 const 给你去掉了------这非常危险。
二、static_cast:日常主力
2.1 定位
编译期完成、语义"良性"的类型转换。 它是我们日常用得最多的一种,绝大多数合法转换都应该用它。
2.2 适用场景
1.基础数值类型互转:int ↔ double、char ↔ int、有无符号互转
枚举与整数互转
2.类层次中的向上转型(派生类指针 → 基类指针)与向下转型(基类 → 派生类)
-
void*与其他对象指针互转(前提:转回去的类型是原来的类型) -
显式调用构造函数 / 转换运算符,比如
static_cast<std::string>(...) -
标准库内部大量使用,例如
std::move的本质就是static_cast<T&&>
2.3 不能做的事
不能去掉 const / volatile
不能把两个不相关 的指针类型互转(int* → double* 编译报错)
不能把整数直接转成指针
向下转型没有运行时检查
2.4 语法
cpp
static_cast<目标类型>(表达式);
2.5 示例
cpp
#include <iostream>
class Base {
public:
virtual ~Base() = default;
};
class Son : public Base {};
int main() {
// 1) 数值转换:会截断小数部分
double a = 3.99;
int b = static_cast<int>(a); // b == 3,注意是截断不是四舍五入
// 2) 向上转型:安全,其实隐式转换也能做
Base* p1 = new Son();
// 3) 向下转型:编译通过,但运行时不做任何检查!
Son* p2 = static_cast<Son*>(p1); // 这里恰好是对的
// 4) 如果 p1 实际指向的是 Base 对象呢?
Base* p3 = new Base();
Son* p4 = static_cast<Son*>(p3); // 编译通过,但 p4 是非法的
// p4->someSonOnlyFunc(); // 未定义行为(UB)
delete p1;
delete p3;
}
2.6 重点提醒
static_cast 做向下转型,只保证"语法上允许 ",不保证"对象真的是那个类型"。它相当于告诉编译器:"我知道我在干什么,你别管。"
一旦你猜错了,就是未定义行为------可能不崩溃、可能读到垃圾值、可能在某个优化等级下突然炸掉,是最难调的一类 bug。
想要运行时检查?那就是下面这位。
三、dynamic_cast:多态体系下的安全向下转型
3.1 定位
在运行时(RTTI)检查类型是否真的匹配,转换失败会给你一个明确的信号,而不是 UB。
3.2 使用条件(必须满足)
目标类型必须是类的指针或引用
源类型必须是多态类型 ------即至少含有一个虚函数(通常是有虚析构函数)
编译器需开启 RTTI(GCC / Clang / MSVC 默认都开启,-fno-rtti 会关闭)
3.3 失败时的行为
| 形式 | 失败结果 |
|---|---|
指针版本 dynamic_cast<T*>(p) |
返回 nullptr |
引用版本 dynamic_cast<T&>(r) |
抛出 std::bad_cast 异常 |
这是很多人忽略的细节:引用版本不会返回"空引用"(语言里也没有这种东西),所以它只能抛异常。写代码时引用版一定要记得 try-catch,或者干脆优先用指针版。
3.4 不能做的事
不能转基础类型(int、double 都没有虚函数表)
不能去掉 const
不能用于没有虚函数的类
3.5 示例
cpp
#include <iostream>
class Base {
public:
virtual void func() {} // 有虚函数 → 多态类型 → 可用 dynamic_cast
virtual ~Base() = default;
};
class Son : public Base {};
int main() {
Base* p = new Base();
Son* s = dynamic_cast<Son*>(p); // 实际类型是 Base,转换失败
if (s == nullptr) {
std::cout << "转换失败\n"; // 会走到这里
}
Base* p2 = new Son();
Son* s2 = dynamic_cast<Son*>(p2); // 成功
if (s2 != nullptr) {
std::cout << "转换成功\n";
}
delete p;
delete p2;
}
3.6 顺带一提:交叉转换
dynamic_cast 还能处理"兄弟类"之间的转换:
cpp
class A { public: virtual ~A() = default; };
class B { public: virtual ~B() = default; };
class C : public A, public B {};
A* pa = new C();
B* pb = dynamic_cast<B*>(pa); // 交叉转换,A 和 B 无继承关系也能转
static_cast 做不了这个------因为编译期它不知道 A* 背后其实是个多继承对象,指针偏移量算不出来。
3.7 代价
dynamic_cast 需要查虚函数表里的 RTTI 信息,逐个比对类型,有运行时开销 ,通常比 static_cast 慢一到两个数量级。
所以:在确定类型的地方用 static_cast,在不确定的地方才用 dynamic_cast 。如果一段代码里 dynamic_cast 满天飞,往往说明你的类设计该用虚函数或者 std::variant 重构了。
四、const_cast:只动 const,不动类型
4.1 定位
唯一作用是添加或移除 const / volatile 属性,绝不改变底层类型。
4.2 适用场景
只能作用于指针、引用、指向成员的指针
典型用途:调用一个"历史遗留"接口,它参数声明成 char* 但内部其实不修改------而你手里只有 const char*
在 const 成员函数里需要把 this 转成非 const(配合 mutable 之外的场景)
4.3 绝对不能做的事
不能改变底层类型(const int* → double* 不行)
不要修改本身就以 const 定义的变量! 这是 UB
4.4 示例
cpp
const int num = 10;
int* p = const_cast<int*>(&num);
// *p = 20; // 未定义行为:num 本身是 const 常量,
// 编译器可能把它放进只读段,也可能直接把 10 内联到使用处
int val = 20;
const int* cp = &val; // 只是"指针带了 const 外衣"
int* vp = const_cast<int*>(cp);
*vp = 30; // 合法:val 本身不是 const
std::cout << val; // 输出 30
4.5 一句话总结
const_cast 不是用来"改常量"的,而是用来解除 const 这层只读外衣的。
判断标准很简单:这个对象原本是不是 const?
1.原本不是 const,只是被 const 指针指着 → 转掉之后修改是合法的;
2.原本就是 const 对象 → 转了之后修改是 UB,程序行为不可预期。
实用建议:
const_cast出现的地方,往往意味着设计上有个不该有的 const。能改签名就改签名,别用转换绕过。
五、reinterpret_cast:二进制重解释,慎用
5.1 定位
把一段内存的比特原样拿过来,按新类型重新理解。不做任何转换、不做任何检查。
这是四种里最危险的,也是唯一"编译器完全不管你对不对"的。
5.2 适用场景
任意指针类型之间互转
指针与整数(uintptr_t / intptr_t)互转
函数指针之间的转换(平台相关)
底层开发:驱动、网络协议解析、序列化、内存池等
5.3 示例
cpp
#include <cstdint>
int a = 0x12345678;
int* p = &a;
// 指针 → 整数
uintptr_t addr = reinterpret_cast<uintptr_t>(p);
// 整数 → 指针
int* p2 = reinterpret_cast<int*>(addr);
// 也可以用 void* 中转,效果类似
void* vp = reinterpret_cast<void*>(p);
5.4 为什么危险
- 对齐问题 :把
char*强转成int*再解引用,如果地址不是 4 字节对齐,某些架构(如 ARM 早期型号)会直接崩溃。 - 严格别名规则 :编译器假设不同类型的指针不会指向同一块内存,用它做优化。你用
reinterpret_cast绕过去读写,可能得到"看起来完全不合逻辑"的结果。 - 可移植性 :32 位下指针 4 字节,64 位下 8 字节;把指针塞进
int在 64 位下直接截断。 - 类型安全彻底失效:编译器不会再帮你拦任何东西。
结论:
reinterpret_cast是"我有充分理由、且清楚目标平台"时的工具,不是日常转换手段。
六、四种转换对比表
| 转换 | 检查时机 | 核心用途 | 典型风险 |
|---|---|---|---|
static_cast |
编译期 | 常规数值转换、枚举转换、合法父子类转换、void* 互转 |
向下转型无运行时检查,猜错即 UB |
dynamic_cast |
运行时(RTTI) | 多态类的安全向下转型、交叉转换 | 仅支持带虚函数的类,有性能开销 |
const_cast |
编译期 | 增删 const / volatile |
修改原生 const 对象是 UB |
reinterpret_cast |
无检查 | 底层比特重解释、指针与整数互转 | 极高风险,不可移植,易违反严格别名 |
再补一张"能力矩阵",一眼看清谁能干什么:
| 能力 | static_cast | dynamic_cast | const_cast | reinterpret_cast |
|---|---|---|---|---|
| 基础类型互转 | 可 | 不可 | 不可 | 不可 |
| 向上转型 | 可 | 可 | 不可 | 可(不推荐) |
| 向下转型 | 可(不检查) | 可(运行时检查) | 不可 | 可(不推荐) |
| 交叉转换 | 不可 | 可 | 不可 | 不可 |
| 去 const | 不可 | 不可 | 可 | 不可 |
| 指针 ↔ 整数 | 不可 | 不可 | 不可 | 可 |
| 不相关指针互转 | 不可 | 不可 | 不可 | 可 |
七、选型口诀
- 普通数值、枚举、合法父子类转换 →
static_cast - 多态类,想安全向下转 →
dynamic_cast - 只需要去掉 const / volatile →
const_cast - 底层地址、比特重解释、底层开发 →
reinterpret_cast - 尽量不用 C 风格强转
(T)x------它等价于"按顺序自动尝试const_cast+static_cast+reinterpret_cast"的混合体,意图模糊、风险不可控。
一句话记忆版:
static 管日常,dynamic 管安全,const 只管 const,reinterpret 管底层。
八、常见面试考点
1:dynamic_cast 为什么要求类必须有虚函数?
因为类型信息(RTTI)是挂在虚函数表上的。没有虚函数就没有虚表,也就没有地方存放"这个对象到底是什么类型",运行时自然无从判断。
另外,没有虚函数的类做向下转型,本身也说明这个类层次不打算支持多态使用------这种场景更应该用 static_cast 并自己保证正确性。
2:const_cast 能不能修改 const 变量?
分情况,关键看对象本身是不是 const:
- 对象本身是 const 常量(
const int num = 10;)→ 修改是 UB; - 对象本身非 const,只是通过 const 指针/引用访问(
int val; const int* p = &val;)→ 转掉 const 后修改是合法的。
注意:即使合法,也不代表是好代码。const_cast 用得越多,说明接口设计越值得怀疑。
3:static_cast 和 dynamic_cast 做向下转型有什么区别?
| static_cast | dynamic_cast | |
|---|---|---|
| 检查时机 | 编译期 | 运行时(RTTI) |
| 是否验证真实类型 | 不验证 | 验证 |
| 失败表现 | 未定义行为 | 指针返回 nullptr,引用抛 std::bad_cast |
| 性能 | 几乎零开销 | 有运行时开销 |
| 使用前提 | 有继承关系即可 | 必须多态类型 |
一句话:static_cast 快但你得保证对,dynamic_cast 慢但它会告诉你错。
4:reinterpret_cast 为什么危险?
因为它只按二进制原样解释,完全不考虑:
- 类型对齐要求;
- 内存布局差异;
- 严格别名规则;
- 平台指针宽度(32/64 位)。
同一段代码在 x86 上跑得好好的,换到 ARM 或者换到 64 位、换到更高优化等级,就可能崩溃或算出错误结果。
5:为什么说 C 风格强转更危险?
因为它会偷偷做 const_cast:
cpp
const int num = 10;
int* p = (int*)# // C 风格强转,悄悄去掉了 const,编译期毫无警告
*p = 20; // UB,但你根本看不出问题出在哪
换成 static_cast<int*>(&num) 会直接编译报错------这就是命名转换的价值:把错误拦在编译期。
九、完整 Demo(可直接运行)
cpp
#include <iostream>
#include <cstdint>
#include <typeinfo>
using namespace std;
class Base {
public:
virtual void show() { cout << "Base" << endl; }
virtual ~Base() = default;
};
class Son : public Base {
public:
void show() override { cout << "Son" << endl; }
};
int main()
{
cout << "===== 1. static_cast =====" << endl;
double d = 3.99;
int i = static_cast<int>(d);
cout << "static_cast: double " << d << " -> int " << i << endl;
// 编译期允许的两个不相关指针转换会报错,可以自己试试:
// int* ip = nullptr;
// double* dp = static_cast<double*>(ip); // 编译错误
cout << "\n===== 2. dynamic_cast =====" << endl;
Base* b1 = new Son();
Son* s1 = dynamic_cast<Son*>(b1);
if (s1) {
cout << "dynamic_cast 成功: ";
s1->show();
}
Base* b2 = new Base();
Son* s2 = dynamic_cast<Son*>(b2);
if (!s2) cout << "dynamic_cast 转换失败(返回 nullptr)" << endl;
// 引用版本失败会抛 std::bad_cast
try {
Son& r = dynamic_cast<Son&>(*b2);
(void)r;
} catch (const bad_cast& e) {
cout << "引用版转换失败: " << e.what() << endl;
}
cout << "\n===== 3. const_cast =====" << endl;
int val = 100;
const int* c_p = &val; // val 本身不是 const
int* v_p = const_cast<int*>(c_p);
*v_p = 200;
cout << "const_cast: val = " << val << endl; // 200
// 危险示范(不要在生产代码里这么写)
// const int c_num = 10;
// int* bad = const_cast<int*>(&c_num);
// *bad = 20; // UB
cout << "\n===== 4. reinterpret_cast =====" << endl;
int x = 666;
int* px = &x;
uintptr_t num = reinterpret_cast<uintptr_t>(px);
int* px2 = reinterpret_cast<int*>(num);
cout << "原始指针地址: " << px << endl;
cout << "reinterpret_cast 转了整数再转回来: " << px2
<< ",取值: " << *px2 << endl;
cout << "两次地址是否一致: " << (px == px2 ? "是" : "否") << endl;
delete b1;
delete b2;
return 0;
}
预期输出(地址值因环境而异):
text
===== 1. static_cast =====
static_cast: double 3.99 -> int 3
===== 2. dynamic_cast =====
dynamic_cast 成功: Son
dynamic_cast 转换失败(返回 nullptr)
引用版转换失败: std::bad_cast
===== 3. const_cast =====
const_cast: val = 200
===== 4. reinterpret_cast =====
原始指针地址: 0x7ffd5c8a1b4c
reinterpret_cast 转了整数再转回来: 0x7ffd5c8a1b4c,取值: 666
两次地址是否一致: 是
十、几个容易踩的坑
1. 把 static_cast 当成"安全转换"
它只保证"编译期语法合法",不保证"运行时对象真的是那个类型"。向下转型一定要自己确认,或者换 dynamic_cast。
2. 用 dynamic_cast 的地方其实不需要 RTTI
如果一个函数只接收 Base*,内部却 dynamic_cast 到三种子类分别处理,那往往说明应该把处理逻辑写成虚函数。
3. 以为 const_cast 能改一切 const
常量可能被放在只读段(如字符串字面量),强行写入直接段错误:
cpp
const char* s = "hello";
char* p = const_cast<char*>(s);
p[0] = 'H'; //段错误 / UB
4. 用 reinterpret_cast 做序列化
不同编译器/平台的字节序、对齐、padding 都不一样。真要序列化,老老实实按字段逐个写,或者用 protobuf / flatbuffers 这类成熟方案。
5. dynamic_cast 在构造函数/析构函数里行为异常
构造和析构期间,对象的动态类型会退化为当前正在构造/析构的那一层,dynamic_cast 往下转必然失败。别在这两个地方用它。
十一、总结
C++ 四种强制转换的本质,是把转换意图显性化:
让阅读代码的人一眼看懂你为什么要强转;
让编译器、静态检查工具(clang-tidy、-Wold-style-cast)能识别并校验;
让"危险操作"在代码里显眼,从而在 Code Review 时被重点关注。
一张图记住选型逻辑:
text
需要转换?
├─ 只是加/去 const、volatile? ──────────→ const_cast
├─ 涉及多态类的向下转型,且不确定真实类型? → dynamic_cast
├─ 数值 / 枚举 / 确定安全的父子类转换? ───→ static_cast
└─ 指针与整数、底层比特重解释? ──────────→ reinterpret_cast(做好平台适配 + 加注释)