C++ 类型转换操作符详解

C++ 提供了四种类型转换操作符，用于替代传统的 C 风格转换，提升代码安全性和可读性。以下是它们的核心特性、异同对比及使用示例：

1. 四大类型转换操作符  

2. 详细解析与使用示例  
2.1 static_cast  
功能：  
• 安全转换：编译时检查类型关系，支持继承类指针转换、基础类型转换等。

• 适用场景：

• 基本类型转换（如 int 转 double）

• 继承体系中的上行转换（派生类指针转基类指针）

• void* 转具体类型指针

示例：  

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

int main() {
  int i = 10;
  double d = static_cast<double>(i);  // 基础类型转换

  Base* base = new Derived();
  Derived* derived = static_cast<Derived*>(base);  // 上行转换（安全）
}

注意：  
• 不进行运行时检查，下行转换可能产生悬空指针。

• 无法处理不相关类型（如 int* 转 double*）。

2.2 dynamic_cast  
功能：  
• 运行时类型检查：通过虚表验证对象类型，确保转换安全。

• 适用场景：

• 多态类的下行转换（基类指针转派生类指针）

• 交叉转换（不同派生类之间的转换）

示例：  

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

int main() {
  Base* base = new Derived();
  Derived* derived = dynamic_cast<Derived*>(base);
  if (derived) {
    derived->g();  // 安全调用派生类方法
  }
}

注意：  
• 基类必须至少有一个虚函数（否则编译失败）。

• 转换失败时，指针返回 nullptr，引用抛出 std::bad_cast。

2.3 const_cast  
功能：  
• 修改常量性：添加或移除 const/volatile 修饰符。

• 适用场景：

• 向旧 API 传递 const 对象

• 重载 const 成员函数

示例：  

void print(int* p) { std::cout << *p; }

int main() {
  const int a = 10;
  print(const_cast<int*>(&a));  // 移除 const 属性（危险！）
}

注意：  
• 修改原本为 const 的对象会导致未定义行为。

• 无法改变对象的实际类型。

2.4 reinterpret_cast  
功能：  
• 底层位模式重解释：直接按位转换，不改变数据内容。

• 适用场景：

• 指针与整数互转（如哈希函数）

• 跨平台硬件交互（如内存地址操作）

示例：  

int main() {
  int i = 42;
  char* p = reinterpret_cast<char*>(&i);  // 将 int 地址视为 char 指针
  std::cout << std::hex << (int)p[0];     // 输出小端系统的低字节（0x2A）
}

注意：  
• 可能导致未定义行为（如将 int* 转为 double* 并解引用）。

• 不同平台对指针和整数的大小可能不同。

3. 对比总结  

4. 使用建议  

1. 优先使用 static_cast：  
   • 适用于明确的类型转换（如数值转换、继承上行转换）。

   • 示例：double d = static_cast<double>(i);  

2. 谨慎使用 dynamic_cast：  
   • 仅在多态类中使用，避免性能损耗。

   • 示例：Derived* d = dynamic_cast<Derived*>(base);  

3. 避免滥用 const_cast：  
   • 仅在确定对象非 const 时使用。

   • 示例：const_cast<int&>(const_var) = 20;（危险！）

4. 极少数情况使用 reinterpret_cast：  
   • 硬件交互、哈希函数等底层操作。

   • 示例：uintptr_t addr = reinterpret_cast<uintptr_t>(&obj);  

5. 错误示例与风险  

// 错误1：static_cast 跨类型转换
class A { int x; };
class B { float y; };
A* a = new A();
B* b = static_cast<B*>(a);  // 编译通过，但未定义行为！

// 错误2：dynamic_cast 用于非多态类
class C { /* 无虚函数 */ };
dynamic_cast<C*>(new C);    // 编译错误！

// 错误3：reinterpret_cast 滥用
int* p = new int(10);
double* dp = reinterpret_cast<double*>(p);  // 未定义行为！

6. 实际应用场景  
• static_cast：

// 数值转换
int i = 10010;
char c = static_cast<char>(i);  // 截断高位字节

• dynamic_cast：

// 多态对象转换
Base* base = getObject();
if (auto derived = dynamic_cast<Derived*>(base)) {
  derived->specificMethod();
}

• const_cast：

// 兼容旧API
const int* src = getData();
old_api(const_cast<int*>(src));  // 移除 const 传递

 
• reinterpret_cast：

// 函数指针转换
void (*funcPtr)() = reinterpret_cast<void(*)()>(0x1000);

7. 总结  
• static_cast：安全转换的首选，适用于日常开发。

• dynamic_cast：多态场景的守护者，确保类型安全。

• const_cast：慎用！仅在必要时修改常量性。

• reinterpret_cast：底层操作的利器，风险与灵活性并存。

理解这些操作符的特性和限制，能显著提升代码安全性和可维护性。