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 類型的整數值，運行結果為：