static_cast和reinterpret_cast揭祕

本文討論static_cast<> 和 reinterpret_cast<>。

reinterpret_cast可以轉換任意一個32bit整數，包括所有的指針和整數。可以把任何整數轉成指針，也可以把任何指針轉成整數，以及把指針轉化爲任意類型的指針，威力最爲強大！但不能將非32bit的實例轉成指針。總之，只要是32bit的東東，怎麼轉都行！ 
static_cast和dynamic_cast可以執行指針到指針的轉換，或實例本身到實例本身的轉換，但不能在實例和指針之間轉換。static_cast只能提供編譯時的類型安全，而dynamic_cast可以提供運行時類型安全。舉個例子： 
class a；class b:a；class c。 
上面三個類a是基類，b繼承a，c和ab沒有關係。 
有一個函數void function(a&a); 
現在有一個對象是b的實例b，一個c的實例c。 
function(static_cast<a&>(b)可以通過而function(static<a&>(c))不能通過編譯，因爲在編譯的時候編譯器已經知道c和a的類型不符，因此static_cast可以保證安全。 
下面我們騙一下編譯器，先把c轉成類型a 
b& ref_b = reinterpret_cast<b&>c; 
然後function(static_cast<a&>(ref_b))就通過了！因爲從編譯器的角度來看，在編譯時並不能知道ref_b實際上是c！ 
而function(dynamic_cast<a&>(ref_b))編譯時也能過，但在運行時就失敗了，因爲dynamic_cast在運行時檢查了ref_b的實際類型，這樣怎麼也騙不過去了。 
在應用多態編程時，當我們無法確定傳過來的對象的實際類型時使用dynamic_cast，如果能保證對象的實際類型，用static_cast就可以了。至於reinterpret_cast，我很喜歡，很象c語言那樣的暴力轉換：）

dynamic_cast:動態類型轉換 
static_cast:靜態類型轉換 
reinterpret_cast:重新解釋類型轉換 
const_cast:常量類型轉換 
專業的上面很多了,我說說我自己的理解吧: 
synamic_cast一般用在父類和子類指針或應用的互相轉化; 
static_cast一般是普通數據類型(如int m=static_cast<int>(3.14)); 
reinterpret_cast很像c的一般類型轉換操作 
const_cast是把cosnt或volatile屬性去掉

.

介紹
大多程序員在學C++前都學過C，並且習慣於C風格（類型）轉換。當寫C++（程序）時，有時候我們在使用static_cast<>和reinterpret_cast<>時可能會有點模糊。在本文中，我將說明static_cast<>實際上做了什麼，並且指出一些將會導致錯誤的情況。

泛型（Generic Types）

float f = 12.3;

        float* pf = &f;
      
        // static cast<>

        // 成功編譯, n = 12

        int n = static_cast<int>(f);

        // 錯誤,指向的類型是無關的（譯註：即指針變量pf是float類型，現在要被轉換爲int類型）
        //int* pn = static_cast<int*>(pf);

        //成功編譯

         void* pv = static_cast<void*>(pf);

        //成功編譯, 但是 *pn2是無意義的內存（rubbish）

         int* pn2 = static_cast<int*>(pv);
      
        // reinterpret_cast<>

        //錯誤,編譯器知道你應該調用static_cast<>

        //int i = reinterpret_cast<int>(f);

        //成功編譯, 但是 *pn 實際上是無意義的內存,和 *pn2一樣

         int* pi = reinterpret_cast<int*>(pf);

簡而言之，static_cast<> 將嘗試轉換，舉例來說，如float-到-integer，而reinterpret_cast<>簡單改變編譯器的意圖重新考慮那個對象作爲另一類型。

指針類型（Pointer Types）

指針轉換有點複雜，我們將在本文的剩餘部分使用下面的類：

class CBaseX

      {

      public:

      int x;

      CBaseX() { x = 10; }

      void foo() { printf("CBaseX::foo() x=%d/n", x); }

      };
      
class CBaseY

        {

        public:

        int y;

        int* py;

        CBaseY() { y = 20; py = &y; }

        void bar() { printf("CBaseY::bar() y=%d, *py=%d/n", y, *py); 
        }

        };

      
class CDerived : public CBaseX, public CBaseY

        {

        public:

        int z;

        };

情況1：兩個無關的類之間的轉換

      // Convert between CBaseX* and CBaseY*

      // CBaseX* 和 CBaseY*之間的轉換

      CBaseX* pX = new CBaseX();

      // Error, types pointed to are unrelated

      // 錯誤， 類型指向是無關的

      // CBaseY* pY1 = static_cast<CBaseY*>(pX);

      // Compile OK, but pY2 is not CBaseX

      // 成功編譯, 但是 pY2 不是CBaseX

      CBaseY* pY2 = reinterpret_cast<CBaseY*>(pX);

      // System crash!!

      // 系統崩潰!!

      // pY2->bar();

正如我們在泛型例子中所認識到的，如果你嘗試轉換一個對象到另一個無關的類static_cast<>將失敗，而reinterpret_cast<>就總是成功“欺騙”編譯器：那個對象就是那個無關類。

情況2：轉換到相關的類

 1. CDerived* pD = new CDerived();

      2. printf("CDerived* pD = %x/n", (int)pD);

      3. 

      4. // static_cast<> CDerived* -> CBaseY* -> CDerived*

      //成功編譯，隱式static_cast<>轉換

      5. CBaseY* pY1 = pD;

      6. printf("CBaseY* pY1 = %x/n", (int)pY1);

      // 成功編譯, 現在 pD1 = pD

      7. CDerived* pD1 = static_cast<CDerived*>(pY1);

      8. printf("CDerived* pD1 = %x/n", (int)pD1);

      9. 

      10. // reinterpret_cast

      // 成功編譯, 但是 pY2 不是 CBaseY*

      11. CBaseY* pY2 = reinterpret_cast<CBaseY*>(pD);

      12. printf("CBaseY* pY2 = %x/n", (int)pY2);

      13. 

      14. // 無關的 static_cast<>

      15. CBaseY* pY3 = new CBaseY();

      16. printf("CBaseY* pY3 = %x/n", (int)pY3);

      // 成功編譯,儘管 pY3 只是一個 "新 CBaseY()"

      17. CDerived* pD3 = static_cast<CDerived*>(pY3);

      18. printf("CDerived* pD3 = %x/n", (int)pD3);
      ---------------------- 輸出 ---------------------------

      CDerived* pD = 392fb8

      CBaseY* pY1 = 392fbc

      CDerived* pD1 = 392fb8

      CBaseY* pY2 = 392fb8

      CBaseY* pY3 = 390ff0

      CDerived* pD3 = 390fec

注意：在將CDerived*用隱式 static_cast<>轉換到CBaseY*（第5行）時，結果是（指向）CDerived*（的指針向後） 偏移了4（個字節）（譯註：4爲int類型在內存中所佔字節數）。爲了知道static_cast<> 實際如何，我們不得不要來看一下CDerived的內存佈局。

CDerived的內存佈局（Memory Layout）

如圖所示，CDerived的內存佈局包括兩個對象，CBaseX 和 CBaseY，編譯器也知道這一點。因此，當你將CDerived* 轉換到 CBaseY*時，它給指針添加4個字節，同時當你將CBaseY*轉換到CDerived*時，它給指針減去4。然而，甚至它即便不是一個CDerived你也可以這樣做。
當然，這個問題只在如果你做了多繼承時發生。在你將CDerived轉換 到 CBaseX時static_cast<> 和 reinterpret_cast<>是沒有區別的。

情況3：void*之間的向前和向後轉換

因爲任何指針可以被轉換到void*，而void*可以被向後轉換到任何指針（對於static_cast<> 和 reinterpret_cast<>轉換都可以這樣做），如果沒有小心處理的話錯誤可能發生。

CDerived* pD = new CDerived();

        printf("CDerived* pD = %x/n", (int)pD);
 

      
    CBaseY* pY = pD; // 成功編譯, pY = pD + 4

        printf("CBaseY* pY = %x/n", (int)pY);

      
      void* pV1 = pY; //成功編譯, pV1 = pY

        printf("void* pV1 = %x/n", (int)pV1);

      
         // pD2 = pY, 但是我們預期 pD2 = pY - 4

        CDerived* pD2 = static_cast<CDerived*>(pV1);

        printf("CDerived* pD2 = %x/n", (int)pD2);

        // 系統崩潰

        // pD2->bar();
        ---------------------- 輸出 ---------------------------

        CDerived* pD = 392fb8

        CBaseY* pY = 392fbc

        void* pV1 = 392fbc

        CDerived* pD2 = 392fbc

一旦我們已經轉換指針爲void*，我們就不能輕易將其轉換回原類。在上面的例子中，從一個void* 返回CDerived*的唯一方法是將其轉換爲CBaseY*然後再轉換爲CDerived*。 
但是如果我們不能確定它是CBaseY* 還是 CDerived*，這時我們不得不用dynamic_cast<> 或typeid[2]。

註釋：
1. dynamic_cast<>，從另一方面來說，可以防止一個泛型CBaseY* 被轉換到CDerived*。
2. dynamic_cast<>需要類成爲多態，即包括“虛”函數，並因此而不能成爲void*。
參考： 
1. [MSDN] C++ Language Reference -- Casting 
2. Nishant Sivakumar, Casting Basics - Use C++ casts in your VC++.NET programs 
3. Juan Soulie, C++ Language Tutorial: Type Casting

轉貼：http://blog.csdn.net/zjl_1026_2001/article/details/2246510