C/C++中类型转换：static_cast, dynamic_cast, const_cast, reinterpret_cast

目的

在C中一般是使用(int) x, (int *)x, (void *) p等方式，但是这种强制类型转换的方式是不安全的，因为他没有类型检查。而且这种转换也是不够精确的。
因此在C++中引入了几种强制类型转换的方式。

定义和作用

1. static_cast：

   1. 提供安全的基本类型转换：但是要注意数据的截断或者改变。（float转换为整数的时候丢失小数部分）。
   2. 类层次间转换：
      向上转换（将派生类的指针/引用转换为基类的指针/引用），这是安全的，因为派生类总是包含基类的全部信息。
      向下转换（将基类的指针/引用转换为派生类的指针/引用），这是不安全的，因为基类不一定包含派生类的全部信息。
   3. 空指针转换为目标类型的空指针：

      class Base {};
      class Derived : public Base {};
      
      Base* b = nullptr;
      Derived* d = static_cast<Derived*>(b);  // 安全转换，d 仍然是 nullptr。
      

   4. non_const转换为const

      int x = 10;
      const int* px = static_cast<const int*>(&x);
      

2. dynamic_cast:
   用于多态，尤其是向下转换和侧向转换（在同一层次结构中的不同类之间）。
   在执行转换时进行运行时检查。如果是安全的（即对象确实是目标类型或其派生类型的实例），则转换成功；如果不安全则转换失败（对于指针，返回nullptr,对于引用抛出异常。

   class Base { virtual void dummy() {} };
   class Derived : public Base { /* ... */ };
   
   Base* basePtr = new Derived();
   
   // 安全的向下转换
   Derived* derivedPtr = dynamic_cast<Derived*>(basePtr);
   

   注意：

   1. 使用dynamin_cast必要要求设计的类至少有一个虚函数，因为涉及多态。
   2. 编译时无法确定转换结果，所以是运行时检查。

   补充侧向转换：
   指的是在同一继承层次中，将一个基类的指针或引用转换为另一个并行基类的指针或引用。
   这种转换通常发生在多重继承的情况下，当一个派生类继承自多个基类时。
   侧向转换的场景
   假设有一个多重继承的类层次结构，其中 Derived 类继承自两个基类 Base1 和 Base2：

   Copy code
   class Base1 { /* ... */ };
   class Base2 { /* ... */ };
   class Derived : public Base1, public Base2 { /* ... */ };
   

   在这种结构中，Derived 同时是 Base1 和 Base2 的子类。如果你有一个指向 Base1 的指针，且它实际上指向的是一个 Derived 类型的对象，你可以使用侧向转换将这个指针安全地转换为指向 Base2 的指针：

   Copy code
   Derived d;
   Base1* b1 = &d;
   Base2* b2 = dynamic_cast<Base2*>(b1); // 侧向转换
   

在这个例子中，dynamic_cast 被用来从 Base1 类型转换到 Base2 类型。由于这两个类是在同一个继承层次中，这样的转换是可能的，并且如果 b1 确实指向一个 Derived 类型的对象，转换将会成功。

3. const_cast:
   去除对象指针/引用的const属性
   const_cast 是 C++ 中的一种类型转换操作符，专门用于修改对象的 const 或 volatile 属性。它是用来改变对象的常量性（const-ness）或易失性（volatility）的。
   使用场景与目的

   1. 移除 const 或 volatile 限定:

      • 当你有一个指向常量的指针或引用，但需要调用一个非常量成员函数或需要修改其指向的数据时，可以使用 const_cast 来移除 const 或 volatile 限定。
      • 这常用于与旧的C风格代码交互，其中数据不是常量，但接口要求传递常量参数。

   2. 添加 const 限定:

      • 虽然不常见，但 const_cast 也可以用来给对象添加 const 限定。这在某些特定情况下可能有用。
        使用示例

   const int a = 10;
   int* b = const_cast<int*>(&a);  // 移除 const 限定
   *b = 20;  // 未定义行为，因为 a 是一个真正的常量
   

   在此例中，尽管 const_cast 成功移除了 const 限定，但对 a 的修改是未定义行为，因为 a 本身是一个常量。

   局限（缺点）

   1. 未定义行为风险:
      如果原始对象实际上是一个常量，尝试修改它的值（即使使用 const_cast 移除了 const 限定）将导致未定义行为。

   2. 安全性问题:
      滥用 const_cast 可能导致代码难以理解和维护，因为它破坏了 const 正确性，这是 C++ 用于保证对象不被意外修改的机制之一。

   3. 限制用途:
      const_cast 只能改变对象的 const/volatile 限定，不能用于改变对象的实际类型。

   4. 破坏封装性:
      在类的上下文中，const_cast 可能会破坏类的封装性，因为它允许修改本应被保护的成员。

4. reinterpret_cast:
   它用于在不兼容类型之间进行转换，基本上是直接重新解释底层的位模式。由于这种转换的低级性质，它通常在特定的系统编程和硬件相关的场景中使用。

   使用场景与目的

   1. 不兼容类型之间的转换:
      用于在完全不相关的类型之间进行转换，例如将指针转换为足够大的整数类型，或将不同类型的指针之间进行转换。
   2. 系统级或硬件相关编程:
      在底层编程中，如操作系统内核或硬件接口编程时，可能需要将指针或其他类型直接转换为某种特定格式。
   3. 函数指针的转换:
      用于将一个类型的函数指针转换为另一个类型。这在需要将函数指针传递给期望不同签名的函数指针参数的回调函数时特别有用。
      示例

   Copy code
   int* ip = new int(42);
   char* cp = reinterpret_cast<char*>(ip);  // 将 int* 转换为 char*
   

   在此示例中，ip 指向一个整数，使用 reinterpret_cast 将其转换为指向 char 的指针。

   局限（缺点）

   1. 类型安全问题:
      reinterpret_cast 不进行任何类型安全检查。它简单地重新解释给定值的位模式，这可能导致未定义行为，特别是在不恰当地解释数据时。
   2. 可移植性问题:
      由于它依赖于特定平台的底层数据表示方式，所以使用 reinterpret_cast 的代码通常缺乏可移植性。
   3. 维护性和可读性问题:
      这种转换的意图不够明确，可能导致代码难以理解和维护。
   4. 潜在的运行时错误:
      错误的使用 reinterpret_cast 可能导致程序崩溃、数据损坏或其他难以调试的运行时错误。

5. 违反别名规则:
   在某些情况下，reinterpret_cast 可能违反 C++ 的严格别名规则（Strict Aliasing Rule），这可能导致编译器优化产生问题。