static_cast、dynamic_cast、const_cast和reinterpret_cast總結（轉）

前言

這篇文章總結的是C++中的類型轉換，這些小的知識點，有的時候，自己不是很注意，但是在實際開發中确實經常使用的。俗話說的好，不懂自己寫的代碼的程式員，不是好的程式員；如果一個程式員對于自己寫的代碼都不懂，隻是知道一昧的的去使用，終有一天，你會迷失你自己的。

C++中的類型轉換分為兩種：

1. 隐式類型轉換；
2. 顯式類型轉換。

而對于隐式變換，就是标準的轉換，在很多時候，不經意間就發生了，比如int類型和float類型相加時，int類型就會被隐式的轉換位float類型，然後再進行相加運算。而關于隐式轉換不是今天總結的重點，重點是顯式轉換。在标準C++中有四個類型轉換符：static_cast、dynamic_cast、const_cast和reinterpret_cast；下面将對它們一一的進行總結。

static_cast

static_cast的轉換格式：static_cast <type-id> (expression)

将expression轉換為type-id類型，主要用于非多态類型之間的轉換，不提供運作時的檢查來確定轉換的安全性。主要在以下幾種場合中使用：

1. 用于類層次結構中，基類和子類之間指針和引用的轉換；

   當進行上行轉換，也就是把子類的指針或引用轉換成父類表示，這種轉換是安全的；

   當進行下行轉換，也就是把父類的指針或引用轉換成子類表示，這種轉換是不安全的，也需要程式員來保證；

2. 用于基本資料類型之間的轉換，如把int轉換成char，把int轉換成enum等等，這種轉換的安全性需要程式員來保證；
3. 把void指針轉換成目标類型的指針，是及其不安全的；

注：static_cast不能轉換掉expression的const、volatile和__unaligned屬性。

dynamic_cast

dynamic_cast的轉換格式：dynamic_cast <type-id> (expression)

将expression轉換為type-id類型，type-id必須是類的指針、類的引用或者是void *；如果type-id是指針類型，那麼expression也必須是一個指針；如果type-id是一個引用，那麼expression也必須是一個引用。

dynamic_cast主要用于類層次間的上行轉換和下行轉換，還可以用于類之間的交叉轉換。在類層次間進行上行轉換時，dynamic_cast和static_cast的效果是一樣的；在進行下行轉換時，dynamic_cast具有類型檢查的功能，比static_cast更安全。在多态類型之間的轉換主要使用dynamic_cast，因為類型提供了運作時資訊。下面我将分别在以下的幾種場合下進行dynamic_cast的使用總結：

1. 最簡單的上行轉換

   比如B繼承自A，B轉換為A，進行上行轉換時，是安全的，如下：

   1 #include <iostream> 2 using namespace std;

   3 class A

   4 {

   5 // ......

   6 };

   7 class B : public A

   8 {

   9 // ......

   10 };

   11 int main()

   12 {

   13 B *pB = new B;

   14 A *pA = dynamic_cast<A *>(pB); // Safe and will succeed

   15 }

2. 多重繼承之間的上行轉換

   C繼承自B，B繼承自A，這種多重繼承的關系；但是，關系很明确，使用dynamic_cast進行轉換時，也是很簡單的：

   1 class A 2 {

   3 // ......

   4 };

   5 class B : public A

   6 {

   7 // ......

   8 };

   9 class C : public B

   10 {

   11 // ......

   12 };

   13 int main()

   14 {

   15 C *pC = new C;

   16 B *pB = dynamic_cast<B *>(pC); // OK

   17 A *pA = dynamic_cast<A *>(pC); // OK

   18 }

   而上述的轉換，static_cast和dynamic_cast具有同樣的效果。而這種上行轉換，也被稱為隐式轉換；比如我們在定義變量時經常這麼寫：B *pB = new C;這和上面是一個道理的，隻是多加了一個dynamic_cast轉換符而已。

3. 轉換成void *

   可以将類轉換成void *，例如：

   3 public:

   4 virtual void f(){}

   7 class B

   9 public:

   10 virtual void f(){}

   15 A *pA = new A;

   16 B *pB = new B;

   17 void *pV = dynamic_cast<void *>(pA); // pV points to an object of A

   18 pV = dynamic_cast<void *>(pB); // pV points to an object of B

   19 }

   但是，在類A和類B中必須包含虛函數，為什麼呢？因為類中存在虛函數，就說明它有想讓基類指針或引用指向派生類對象的情況，此時轉換才有意義；由于運作時類型檢查需要運作時類型資訊，而這個資訊存儲在類的虛函數表中，隻有定義了虛函數的類才有虛函數表。

4. 如果expression是type-id的基類，使用dynamic_cast進行轉換時，在運作時就會檢查expression是否真正的指向一個type-id類型的對象，如果是，則能進行正确的轉換，獲得對應的值；否則傳回NULL，如果是引用，則在運作時就會抛出異常；例如：

   1 class B 2 {

   3 virtual void f(){};

   5 class D : public B

   7 virtual void f(){};

   9 void main()

   11 B* pb = new D; // unclear but ok

   12 B* pb2 = new B;

   13 D* pd = dynamic_cast<D*>(pb); // ok: pb actually points to a D

   14 D* pd2 = dynamic_cast<D*>(pb2); // pb2 points to a B not a D, now pd2 is NULL

   這個就是下行轉換，從基類指針轉換到派生類指針。

   對于一些複雜的繼承關系來說，使用dynamic_cast進行轉換是存在一些陷阱的；比如，有如下的一個結構：

   D類型可以安全的轉換成B和C類型，但是D類型要是直接轉換成A類型呢？

   3 virtual void Func() = 0;

   7 void Func(){};

   9 class C : public A

   11 void Func(){};

   13 class D : public B, public C

   15 void Func(){}

   16 };

   17 int main()

   18 {

   19 D *pD = new D;

   20 A *pA = dynamic_cast<A *>(pD); // You will get a pA which is NULL

   21 }

   如果進行上面的直接轉，你将會得到一個NULL的pA指針；這是因為，B和C都繼承了A，并且都實作了虛函數Func，導緻在進行轉換時，無法進行抉擇應該向哪個A進行轉換。正确的做法是：

   1 int main()2 {

   3 D *pD = new D;

   4 B *pB = dynamic_cast<B *>(pD);

   5 A *pA = dynamic_cast<A *>(pB);

   6 }

   這就是我在實作QueryInterface時，得到IUnknown的指針時，使用的是*ppv = static_cast<IX *>(this);而不是*ppv = static_cast<IUnknown *>(this);

   對于多重繼承的情況，從派生類往父類的父類進行轉時，需要特别注意；比如有下面這種情況：

   現在，你擁有一個A類型的指針，它指向E執行個體，如何獲得B類型的指針，指向E執行個體呢？如果直接進行轉的話，就會出現編譯器出現分歧，不知道是走E->C->B，還是走E->D->B。對于這種情況，我們就必須先将A類型的指針進行下行轉換，獲得E類型的指針，然後，在指定一條正确的路線進行上行轉換。

上面就是對于dynamic_cast轉換的一些細節知識點，特别是對于多重繼承的情況，在實際項目中，很容易出現問題。

const_cast

const_cast的轉換格式：const_cast <type-id> (expression)

const_cast用來将類型的const、volatile和__unaligned屬性移除。常量指針被轉換成非常量指針，并且仍然指向原來的對象；常量引用被轉換成非常量引用，并且仍然引用原來的對象。看以下的代碼例子：

1 /*
 2 ** FileName     : ConstCastDemo
 3 ** Author       : Jelly Young
 4 ** Date         : 2013/12/27
 5 ** Description  : More information, please go to http://www.jellythink.com
 6 */
 7 #include <iostream>
 8 using namespace std;
 9 class CA
10 {
11 public:
12      CA():m_iA(10){}
13      int m_iA;
14 };
15 int main()
16 {
17      const CA *pA = new CA;
18      // pA->m_iA = 100; // Error
19      CA *pB = const_cast<CA *>(pA);
20      pB->m_iA = 100;
21      // Now the pA and the pB points to the same object
22      cout<<pA->m_iA<<endl;
23      cout<<pB->m_iA<<endl;
24      const CA &a = *pA;
25      // a.m_iA = 200; // Error
26      CA &b = const_cast<CA &>(a);
27      b.m_iA = 200;
28      // Now the a and the b reference to the same object
29      cout<<b.m_iA<<endl;
30      cout<<a.m_iA<<endl;
31 }      

注：你不能直接對非指針和非引用的變量使用const_cast操作符去直接移除它的const、volatile和__unaligned屬性。

reinterpret_cast

reinterpret_cast的轉換格式：reinterpret_cast <type-id> (expression)

允許将任何指針類型轉換為其它的指針類型；聽起來很強大，但是也很不靠譜。它主要用于将一種資料類型從一種類型轉換為另一種類型。它可以将一個指針轉換成一個整數，也可以将一個整數轉換成一個指針，在實際開發中，先把一個指針轉換成一個整數，在把該整數轉換成原類型的指針，還可以得到原來的指針值；特别是開辟了系統全局的記憶體空間，需要在多個應用程式之間使用時，需要彼此共享，傳遞這個記憶體空間的指針時，就可以将指針轉換成整數值，得到以後，再将整數值轉換成指針，進行對應的操作。