接上文：C语言的隐式类型转换和显示类型转换

隐式类型转换是编译器自动隐式进行的，需要在代码中体现，而显示类型转换由程序员明确指定。

C++支持C风格的强制转换，但是C风格的强制转换可能带来一些隐患，让一些问题难以发现。

所以C++提供了一组适用于不同场景的强制转换的函数：

• static_cast
• dynamic_cast
• const_cast
• reinterpret_cast

下面对这四种转换操作的适用场景分别进行说明。

1、static_cast

static_cast<type>(expression)

该运算符把 expression 转换为 type 类型，主要用于基本数据类型之间的转换，如把 uint 转换为 int，把 int 转换为 double 等。

uint x = 1;
int y = static_cast<int>(x); // 转换正确
int x = 1;
double y = static_cast<double>(x); // 转换正确

需要注意的是：static_cast 没有运行时类型检查来保证转换的安全性，需要程序员来判断转换是否安全。

int x = -1;
uint y = static_cast<uint>(x) // 转换错误
double x = 1.23;
int y = static_cast<int>(x) // 转换丢失精度

static_cast 还可用于类层次结构中，基类和派生类之间指针或引用的转换，但也要注意：

• static_cast 进行上行转换是安全的，即把派生类的指针转换为基类的；
• static_cast 进行下行转换是不安全的，即把基类的指针转换为派生类的。

// 上行转换，派生类→基类
Derive* d = new Derive();
Base* b = static_cast<Base*>(d);// 下行转换，基类→派生类
Base* b = new Base();
Derive* d = static_cast<Derive*>(b);

这是因为派生类包含基类信息，所以上行转换（只能调用基类的方法和成员变量），一般是安全的；

而基类没有派生类的任何信息，而下行转换后会用到派生类的方法和成员变量，这些基类都没有，很容易“指鹿为马”，或指向不存在的空间。

2、dynamic_cast

dynamic_cast<type>(expression)

dynamic_cast 主要用于类层次间的上行转换或下行转换。在进行上行转换时，dynamic_cast 和 static_cast 的效果是一样的，但在下行转换时，dynamic_cast 具有类型检查的功能，比 static_cast 更安全。

比如下面这段代码：

#include <IOStream>
using namespace std;
class Base {
public:
    virtual void Say() {
        cout << "I am Base." << endl;
    }};class Derive : public Base {
public:
    virtual void Say() {
        cout << "I am Derive." << endl;
    }};int main(){    // 上行转换
    Derive* d1 = new Derive();
    cout << "d1: " << d1 << endl;
    Base* b1 = dynamic_cast<Base*>(d1);
    cout << "b1: " << b1 << endl;
  
    // 下行转换
    Base* b2 = new Base();
    cout << "b2: " << b2 << endl;
    Derive* d2 = dynamic_cast<Derive*>(b2);
    cout << "d2: " << d2 << endl;
    return 0;
}

运行结果为：

在进行下行转换时，从基类 b2 到 d2 时，d2 会改为空指针（0x0），这正是 dynamic_cast 提升安全的功能。这个检查主要来自虚函数表。

在C++面向对象的思想中，虚函数是实现多态的关键机制。当一个类中有虚函数时，那么编译器就会构建出一个虚函数表来指示这些函数的地址。当用基类的指针指向派生类的对象，调用方法时就会根据虚函数表找到对应派生类的方法。

注意：B 要有虚函数，否则会编译出错；static_cast则没有这个限制。

这是由于运行时类型检查需要运行时类型信息，而这个信息存储在类的虚函数表，只有定义了虚函数的类才有虚函数表，没有定义虚函数的类是没有虚函数表的。

3、const_cast

const_cast<type>(expression)

该运算符用来修改 expression 的 const 或 volatile 属性。这里需要注意：expression 和 type 的类型一样的。

比如下面的代码，指针 px 由于有 const 修饰，无法直接通过其修改 x 的值，但又期望能修改 x 的值时，怎么办呢？这时就需要用到 const_cast。

int main()
{    int x = 1;
    cout << "before: " << x << endl;
      const int* px = &x;
    // *px = 2; // 编译错误
      int* py = const_cast<int*>(px);
    *py = 2;
      cout << "px: " << px << endl;
    cout << "py: " << py << endl;
    cout << "after : " << x << endl;
      return 0;
}

运行结果为：

可以看出，px 和 py 指向同一个地址，但通过 py 就可以修改 x 的值了。

这是因为通过const_cast，就把 const 类型的指针 px 转换成非 const 类型的指针 py 了。

4、reinterpret_cast

reinterpret_cast<type>(expression)

该运算符可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针。

int main()
{    int* p = new int(5);
    uint64_t p_val = reinterpret_cast<uint64_t>(p);
      cout << "p    :" << p << endl;
    cout << "p_val:" << hex << p_val << endl;
      return 0;
}

上述代码把指针 p 的地址值转换成了 uint64_t 类型的整数值，运行结果为：

这个转换是“最不安全”的。不推荐使用。

综上，在使用强制类型转换时，需要首先考虑清楚使用目的，总结如下：

• static_cast：基本类型转换，低风险；
• dynamic_cast：类层次间的上行转换或下行转换，低风险；
• const_cast：去 const 属性，低风险；
• reinterpret_cast：转换不相关的类型，高风险。