C++ 类型转换深度解析：static_cast、dynamic_cast、const_cast、reinterpret_cast

引言

在 C 语言中，类型转换的语法非常简单——只需在变量前加上目标类型即可。但这种转换缺乏安全性检查，容易导致未定义行为。C++ 引入了四种命名的强制类型转换运算符，它们提供了更细粒度的转换控制和更高的可读性。

四种类型转换分别是：

• static_cast：静态转换，编译时确定

• dynamic_cast：动态转换，运行时检查（依赖 RTTI）

• const_cast：常量转换，添加或移除 const 属性

• reinterpret_cast：重解释转换，最不安全的底层转换

今天，我将从使用场景、底层原理和安全性角度，全面讲解这四种类型转换。

第一部分：静态转换（static_cast）

一、基本概念

static_cast是最常用的类型转换，用于编译时可以确定的类型转换。它在编译期进行类型检查，比 C 风格转换更安全。

static_cast<目标类型>(源表达式)

二、支持的类型转换

1. 基本数据类型之间的转换

#include <iostream> using namespace std; int main() { // 整数与浮点数转换 double pi = 3.14159; int pi_int = static_cast<int>(pi); // 3，小数部分截断 cout << "pi_int = " << pi_int << endl; // 整数与字符转换 char ch = 'A'; int ascii = static_cast<int>(ch); // 65 cout << "ASCII of 'A' = " << ascii << endl; // 大类型转小类型（可能溢出） long long big = 99999111001010LL; int small = static_cast<int>(big); // 截断高位 cout << "long long to int: " << small << endl; return 0; }

2. void* 与任意类型指针的互转

int main() { int n = 100; // int* → void* void* vp = static_cast<void*>(&n); // void* → char* char* cp = static_cast<char*>(vp); // 通过 char* 逐字节访问 for (int i = 0; i < sizeof(int); i++) { printf("%02X ", (unsigned char)cp[i]); } cout << endl; return 0; }

3. 基类与派生类之间的转换

class F { public: void show() { cout << "F show()" << endl; } }; class S : public F { public: void show() { cout << "S show()"" << endl; } }; int main() { F f; S s; // 子类对象转换为父类对象（切片） F f2 = static_cast<F>(s); // 调用拷贝构造，派生类部分被切掉 f2.show(); // F show() // 父类指针转子类指针（危险，但编译允许） F* fp = &f; S* sp2 = static_cast<S*>(fp); sp2->show(); // S show()（但对象实际是F，访问派生类成员会出问题） // 子类指针转父类指针（安全） S* sp = &s; F* fp2 = static_cast<F*>(sp); fp2->show(); // F show() return 0; }

重要规则：

• 非指针/引用时：子类对象可以转换为父类对象（切片），父类对象不能转换为子类对象

• 指针/引用时：子类指针可以转换为父类指针，父类指针转子类指针需要谨慎

4. 左值转右值引用（std::move 的本质）

#include <utility> // for std::move int main() { int n = 100; // static_cast 实现左值转右值引用 int&& rref1 = static_cast<int&&>(n); // std::move 内部就是 static_cast int&& rref2 = std::move(n); cout << "rref1 = " << rref1 << endl; cout << "rref2 = " << rref2 << endl; return 0; }

第二部分：动态转换（dynamic_cast）

一、基本概念

dynamic_cast是 C++ 中唯一的运行时类型转换，它依赖于RTTI（Runtime Type Information，运行时类型识别）机制。转换失败时，指针版本返回nullptr，引用版本抛出std::bad_cast异常。

dynamic_cast<目标类型>(源表达式)

二、使用前提

关键条件：基类必须至少有一个虚函数（因为 RTTI 信息存储在虚函数表中）。

class A { public: virtual void hi() { cout << "A hi()" << endl; } // 必须有虚函数 }; class B : public A { public: void hi() override { cout << "B hi()" << endl; } };

三、向上转型（子类 → 父类）

向上转型总是安全的，dynamic_cast和static_cast效果相同。

int main() { B b; // 子类对象转父类引用 A& a_ref = dynamic_cast<A&>(b); a_ref.hi(); // B hi()（多态） // 子类指针转父类指针 A* a_ptr = dynamic_cast<A*>(&b); a_ptr->hi(); // B hi() return 0; }

四、向下转型（父类 → 子类）

向下转型是dynamic_cast的核心应用，它会在运行时检查类型是否匹配。

int main() { A a; B b; // 情况1：父类指针指向子类对象 → 转换成功 A* a_ptr_to_b = &b; B* b_ptr = dynamic_cast<B*>(a_ptr_to_b); if (b_ptr != nullptr) { cout << "转换成功："; b_ptr->hi(); // B hi() } // 情况2：父类指针指向父类对象 → 转换失败 A* a_ptr_to_a = &a; B* b_ptr2 = dynamic_cast<B*>(a_ptr_to_a); if (b_ptr2 == nullptr) { cout << "转换失败，返回 nullptr" << endl; } // 引用的版本：转换失败会抛出异常 try { B& b_ref = dynamic_cast<B&>(a); b_ref.hi(); } catch (const bad_cast& e) { cout << "引用转换失败：" << e.what() << endl; } return 0; }

五、dynamic_cast 的原理

第三部分：常量转换（const_cast）

一、基本概念

const_cast用于添加或移除变量的const或volatile属性。它是唯一能处理常量的转换运算符。

const_cast<目标类型>(源表达式)

二、移除 const 属性

int main() { const int n = 10; // 移除 const，获得可修改的指针 int* np = const_cast<int*>(&n); *np = 100; cout << "np = " << np << ", *np = " << *np << endl; cout << "&n = " << &n << ", n = " << n << endl; // 注意：虽然地址相同，但值可能不同（常量折叠优化）！ // 编译器可能将 n 替换为字面量 10，导致输出不一致 return 0; }

三、添加 const 属性

int main() { int n = 10; int* np = &n; // 添加 const 属性 const int* cnp = const_cast<const int*>(np); // *cnp = 20; // 错误！不能通过 const 指针修改 // 引用版本 int& nr = n; const int& cnr = const_cast<const int&>(nr); return 0; }

四、重要警告

int main() { // 危险：修改真正的 const 变量是未定义行为 const int const_value = 100; int* p = const_cast<int*>(&const_value); *p = 200; // 未定义行为！可能导致程序崩溃或值不变 // 安全：修改的是一开始就不是 const 的变量 int mutable_value = 100; const int& ref = mutable_value; int* q = const_cast<int*>(&ref); *q = 200; // 安全，因为 mutable_value 本身不是 const cout << "mutable_value = " << mutable_value << endl; return 0; }

第四部分：重解释转换（reinterpret_cast）

一、基本概念

reinterpret_cast是最不安全的类型转换，它直接重新解释内存中的二进制位，不进行任何类型检查。主要用于底层编程、硬件访问、序列化等场景。

reinterpret_cast<目标类型>(源表达式)

二、指针类型之间的重解释

#include <iostream> using namespace std; class A { public: int x = 1; int y = 2; }; class B { public: int arr[2]{5, 9}; }; int main() { A a; B b; // 将 A 对象重解释为 B 对象 B& bf = reinterpret_cast<B&>(a); cout << bf.arr[0] << "," << bf.arr[1] << endl; // 1,2 // 将 a.x 解释为 arr[0]，a.y 解释为 arr[1] return 0; }

三、任意类型指针互转

int main() { string s = "123"; // 将 string 对象地址重解释为 int* int* n = reinterpret_cast<int*>(&s); // cout << *n << endl; // 危险！将 string 的内存解释为 int // 将 string 对象地址重解释为 char*，逐字节查看 char* p = reinterpret_cast<char*>(&s); for (int i = 0; i < sizeof(string); i++) { cout << hex << (int)(unsigned char)p[i] << " "; } cout << endl; return 0; }

四、整数与指针互转

int main() { int addr = 0x12345678; // 整数转指针（危险！通常用于嵌入式或驱动开发） int* p = reinterpret_cast<int*>(addr); // *p = 100; // 如果地址无效，程序崩溃 // 指针转整数 int val = reinterpret_cast<long long>(p); cout << "指针值作为整数: " << hex << val << endl; return 0; }

第五部分：四种转换对比总结

一、功能对比表

二、使用建议

// 1. 优先使用 static_cast 代替 C 风格转换 int a = 10; double b = static_cast<double>(a); // 推荐 double c = (double)a; // 不推荐 // 2. 多态向下转型使用 dynamic_cast Base* base = new Derived(); Derived* derived = dynamic_cast<Derived*>(base); if (derived) { // 安全使用 derived } // 3. 只在必要时使用 const_cast，且确保原值不是 const void readOnly(const int* p) { // 如果确定 p 指向的是非 const 变量 int* writable = const_cast<int*>(p); *writable = 100; } // 4. 尽量避免使用 reinterpret_cast，除非底层编程 // 序列化/反序列化时可用

三、类型转换选择流程图

第六部分：完整示例

#include <iostream> #include <typeinfo> using namespace std; // 基类（必须有虚函数才能使用 dynamic_cast） class Animal { public: virtual void speak() const { cout << "Animal speaks" << endl; } virtual ~Animal() {} }; class Dog : public Animal { public: void speak() const override { cout << "Woof!" << endl; } void wagTail() const { cout << "Tail wagging" << endl; } }; class Cat : public Animal { public: void speak() const override { cout << "Meow!" << endl; } void purr() const { cout << "Purring" << endl; } }; // 演示四种转换 int main() { cout << "=== 1. static_cast 演示 ===" << endl; int i = 10; double d = static_cast<double>(i); // 基本类型转换 cout << "int to double: " << d << endl; void* vp = static_cast<void*>(&i); int* ip = static_cast<int*>(vp); cout << "void* to int*: " << *ip << endl; cout << "\n=== 2. dynamic_cast 演示 ===" << endl; Animal* animals[2] = {new Dog(), new Cat()}; for (int i = 0; i < 2; i++) { animals[i]->speak(); // 向下转型 Dog* dog = dynamic_cast<Dog*>(animals[i]); if (dog) { dog->wagTail(); } Cat* cat = dynamic_cast<Cat*>(animals[i]); if (cat) { cat->purr(); } } cout << "\n=== 3. const_cast 演示 ===" << endl; int value = 100; const int& const_ref = value; // 移除 const（安全，因为原值不是 const） int& mutable_ref = const_cast<int&>(const_ref); mutable_ref = 200; cout << "Original value: " << value << endl; const int const_value = 300; int* p = const_cast<int*>(&const_value); // *p = 400; // 危险！未定义行为 cout << "\n=== 4. reinterpret_cast 演示 ===" << endl; long long addr = 0x12345678; int* ptr = reinterpret_cast<int*>(addr); cout << "Address as pointer: " << ptr << endl; float f = 3.14f; int* f_as_int = reinterpret_cast<int*>(&f); cout << "Float as int: " << hex << *f_as_int << dec << endl; // 清理内存 delete animals[0]; delete animals[1]; return 0; }

总结

一、四种转换核心要点

二、原则

1. 优先使用 C++ 风格转换：可读性更好，意图更明确

2. 避免使用 reinterpret_cast：除非绝对必要

3. dynamic_cast 需要虚函数：这是 RTTI 工作的前提

4. const_cast 要小心：修改真正 const 变量是未定义行为

C++ 的四种类型转换提供了比 C 风格转换更精细的控制。理解它们的区别和适用场景，能够帮助你写出更安全、更可读的代码。

学习建议：

1. 日常开发优先使用static_cast

2. 多态向下转型使用dynamic_cast

3. 只在必要时使用const_cast

4. reinterpret_cast仅在底层编程中使用