C++的四種cast操作符的區別

Q:什麼是C風格轉換？什麼是static_cast, dynamic_cast 以及 reinterpret_cast？區別是什嗎？為什麼要注意？

A:轉換的含義是通過改變一個變數的類型為別的類型從而改變該變數的表示方式。為了類型轉換一個簡單對象為另一個對象你會使用傳統的類型轉換操作符。比如，為了轉換一個類型為doubole的浮點數的指標到整型：
代碼:
int i;
double d;

i = (int) d;
或者：

i = int (d);

對於具有標準定義轉換的簡單類型而言工作的很好。然而，這樣的轉換符也能不分皂白的應用於類（class）和類的指標。ANSI-C++標準定義了四個新的轉換符：'reinterpret_cast', 'static_cast', 'dynamic_cast' 和 'const_cast'，目的在於控制類(class)之間的類型轉換。
代碼:
reinterpret_cast<new_type>(expression)
dynamic_cast<new_type>(expression)
static_cast<new_type>(expression)
const_cast<new_type>(expression)

1 reinterpret_cast

'reinterpret_cast'轉換一個指標為其它類型的指標。它也允許從一個指標轉換為整數類型。反之亦然。（譯註：是指標具體的地址值作為整數值？）
這個操作符能夠在非相關的類型之間轉換。操作結果只是簡單的從一個指標到別的指標的值的二進位拷貝。在類型之間指向的內容不做任何類型的檢查和轉換。

如果情況是從一個指標到整型的拷貝，內容的解釋是系統相關的，所以任何的實現都不是方便的。一個轉換到足夠大的整型能夠包含它的指標是能夠轉換回有效指標的。

代碼:
class A {};
class B {};

A * a = new A;
B * b = reinterpret_cast<B *>(a);
'reinterpret_cast'就像傳統的類型轉換一樣對待所有指標的類型轉換。

2 static_cast

'static_cast'允許執行任意的隱式轉換和相反轉換動作。（即使它是不允許隱式的）

應用到類的指標上，意思是說它允許子類類型的指標轉換為父類類型的指標（這是一個有效隱式轉換），同時，也能夠執行相反動作：轉換父類為它的子類。

在這最後例子裡，被轉換的父類沒有被檢查是否與目的類型相一致。
代碼：
class Base {};
class Derived : public Base {};

Base *a     = new Base;
Derived *b = static_cast<Derived *>(a);
'static_cast'除了操作類型指標，也能用於執行類型定義的顯式的轉換，以及基礎類型之間的標準轉換:

代碼:
double d = 3.14159265;
int     i = static_cast<int>(d);

3 dynamic_cast

'dynamic_cast'只用於對象的指標和引用。當用於多態類型時，它允許任意的隱式類型轉換以及相反過程。不過，與static_cast不同，在後一種情況裡（註：即隱式轉換的相反過程），dynamic_cast會檢查操作是否有效。也就是說，它會檢查轉換是否會返回一個被請求的有效完整對象。
檢測在運行時進行。如果被轉換的指標不是一個被請求的有效完整的對象指標，傳回值為NULL.
代碼：
class Base { virtual dummy() {} };
class Derived : public Base {};

Base* b1 = new Derived;
Base* b2 = new Base;

Derived* d1 = dynamic_cast<Derived *>(b1);           // succeeds
Derived* d2 = dynamic_cast<Derived *>(b2);           // fails: returns 'NULL'

如果一個參考型別執行了類型轉換並且這個轉換是不可能的，一個bad_cast的異常類型被拋出：
代碼:
class Base { virtual dummy() {} };
class Derived : public Base { };

Base* b1 = new Derived;
Base* b2 = new Base;

Derived d1 = dynamic_cast<Derived &*>(b1);           // succeeds
Derived d2 = dynamic_cast<Derived &*>(b2);           // fails: exception thrown

4 const_cast

這個轉換類型操縱傳遞對象的const屬性，或者是設定或者是移除：
代碼:
class C {};

const C *a = new C;

C *b = const_cast<C *>(a);
其它三種操作符是不能修改一個對象的常量性的。
注意：'const_cast'也能改變一個類型的volatile qualifier。

--------------------------------------------------------------------

C++的4種類型轉換

     一、C 風格（C-style）強制轉型如下：

     (T) expression // cast expression to be of type T
     函數風格（Function-style）強制轉型使用這樣的文法：
     T(expression) // cast expression to be of type T
     這兩種形式之間沒有本質上的不同，它純粹就是一個把括弧放在哪的問題。我把這兩種形式稱為舊風格（old-style）的強制轉型。

    二、 C++的四種強制轉型形式：

　　C++ 同時提供了四種新的強制轉型形式（通常稱為新風格的或 C++ 風格的強制轉型）：
　　const_cast(expression)
　　dynamic_cast(expression)
　　reinterpret_cast(expression)
　　static_cast(expression)

　　每一種適用於特定的目的：

　　·dynamic_cast 主要用於執行“安全的向下轉型（safe downcasting）”，也就是說，要確定一個對象是否是一個繼承體系中的一個特定類型。它是唯一不能用舊風格文法執行的強制轉型，也是唯一可能有重大運行時代價的強制轉型。
    
     ·static_cast 可以被用於強制隱型轉換（例如，non-const 對象轉型為 const 對象，int 轉型為 double，等等），它還可以用於很多這樣的轉換的反向轉換（例如，void* 指標轉型為有類型指標，基類指標轉型為衍生類別指標），但是它不能將一個 const 對象轉型為 non-const 對象（只有 const_cast 能做到），它最接近於C-style的轉換。
    
　　·const_cast 一般用於強制消除對象的常量性。它是唯一能做到這一點的 C++ 風格的強制轉型。

　　·reinterpret_cast 是特意用於底層的強制轉型，導致實現依賴（implementation-dependent）（就是說，不可移植）的結果，例如，將一個指標轉型為一個整數。這樣的強制轉型在底層代碼以外應該極為罕見。
　　
　　舊風格的強制轉型依然合法，但是新的形式更可取。首先，在代碼中它們更容易識別（無論是人還是像 grep 這樣的工具都是如此），這樣就簡化了在代碼中尋找類型系統被破壞的地方的過程。第二，更精確地指定每一個強制轉型的目的，使得編譯器診斷使用錯誤成為可能。例如，如果你試圖使用一個 const_cast 以外的新風格強制轉型來消除常量性，你的代碼將無法編譯。

==  
==   dynamic_cast .vs. static_cast
==

class B { ... };
class D : public B { ... };

void f(B* pb)
{
    D* pd1 = dynamic_cast<D*>(pb);
    D* pd2 = static_cast<D*>(pb);
}

If pb really points to an object of type D, then pd1 and pd2 will get the same value. They will also get the same value if pb == 0.

If pb points to an object of type B and not to the complete D class, then dynamic_cast will know enough to return zero. However, static_cast relies on the programmer’s assertion that pb points to an object of type D and simply returns a pointer to that supposed D object.

     即dynamic_cast可用於繼承體系中的向下轉型，即將基類指標轉換為衍生類別指標，比static_cast更嚴格更安全。dynamic_cast在執行效率上比static_cast要差一些,但static_cast在更寬上範圍內可以完成映射,這種不加限制的映射伴隨著不安全性.static_cast覆蓋的變換類型除類層次的靜態導航以外,還包括無映射變換,窄化變換(這種變換會導致對象切片,丟失資訊),用VOID*的強制變換,隱式類型變換等...

==
==   static_cast .vs. reinterpret_cast
==

     reinterpret_cast是為了映射到一個完全不同類型的意思,這個關鍵詞在我們需要把類型映射回原有類型時用到它.我們映射到的類型僅僅是為了故弄玄虛和其他目的,這是所有映射中最危險的.(這句話是C++編程思想中的原話)

     static_cast 和 reinterpret_cast 操作符修改了運算元類型. 它們不是互逆的; static_cast 在編譯時間使用類型資訊執行轉換, 在轉換執行必要的檢測(諸如指標越界計算, 類型檢查). 其運算元相對是安全的. 另一方面, reinterpret_cast 僅僅是重新解釋了給出的對象的位元模型而沒有進行二進位轉換, 例子如下:

     int n=9; double d=static_cast < double > (n);

     上面的例子中, 我們將一個變數從 int 轉換到 double. 這些類型的二進位運算式是不同的. 要將整數 9 轉換到 雙精確度整數 9, static_cast 需要正確地為雙精確度整數 d 補足位元位. 其結果為 9.0. 而reinterpret_cast 的行為卻不同:

     int n=9;
     double d=reinterpret_cast<double & > (n);

     這次, 結果有所不同. 在進行計算以後, d 包含無用值. 這是因為 reinterpret_cast 僅僅是複製 n 的位元位到 d, 沒有進行必要的分析.