C++中的類型轉換static_cast、dynamic_cast、const_cast和reinterpret_cast總結

C++中的類型轉換static_cast、dynamic_cast、const_cast和reinterpret_cast總結_C 語言_腳本之家
http://www.jb51.net/article/55885.htm

這篇文章主要介紹了C++中的類型轉換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，進行上行轉換時，是安全的，以下：

複製代碼代碼以下:

#include <iostream>
using namespace std;
class A
{
     // ......
};
class B : public A
{
     // ......
};
int main()
{
     B *pB = new B;
     A *pA = dynamic_cast<A *>(pB); // Safe and will succeed
}

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

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

複製代碼代碼以下:

class A
{
     // ......
};
class B : public A
{
     // ......
};
class C : public B
{
     // ......
};
int main()
{
     C *pC = new C;
     B *pB = dynamic_cast<B *>(pC); // OK
     A *pA = dynamic_cast<A *>(pC); // OK
}

而上述的轉換，static_cast和dynamic_cast具備一樣的效果。而這種上行轉換，也被稱爲隱式轉換；好比咱們在定義變量時常常這麼寫：B *pB = new C;這和上面是一個道理的，只是多加了一個dynamic_cast轉換符而已。

3.轉換成void *

能夠將類轉換成void *，例如：

複製代碼代碼以下:

class A
{
public:
     virtual void f(){}
     // ......
};
class B
{
public:
     virtual void f(){}
     // ......
};
int main()
{
     A *pA = new A;
     B *pB = new B;
     void *pV = dynamic_cast<void *>(pA); // pV points to an object of A
     pV = dynamic_cast<void *>(pB); // pV points to an object of B
}

可是，在類A和類B中必須包含虛函數，爲何呢？由於類中存在虛函數，就說明它有想讓基類指針或引用指向派生類對象的狀況，此時轉換纔有意義；因爲運行時類型檢查須要運行時類型信息，而這個信息存儲在類的虛函數表中，只有定義了虛函數的類纔有虛函數表。

4.若是expression是type-id的基類，使用dynamic_cast進行轉換時，在運行時就會檢查expression是否真正的指向一個type-id類型的對象，若是是，則能進行正確的轉換，得到對應的值；不然返回NULL，若是是引用，則在運行時就會拋出異常；例如：

複製代碼代碼以下:

class B
{
     virtual void f(){};
};
class D : public B
{
     virtual void f(){};
};
void main()
{
     B* pb = new D;   // unclear but ok
     B* pb2 = new B;
     D* pd = dynamic_cast<D*>(pb);   // ok: pb actually points to a D
     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類型呢？

複製代碼代碼以下:

class A
{
     virtual void Func() = 0;
};
class B : public A
{
     void Func(){};
};
class C : public A
{
     void Func(){};
};
class D : public B, public C
{
     void Func(){}
};
int main()
{
     D *pD = new D;
     A *pA = dynamic_cast<A *>(pD); // You will get a pA which is NULL
}

若是進行上面的直接轉，你將會獲得一個NULL的pA指針；這是由於，B和C都繼承了A，而且都實現了虛函數Func，致使在進行轉換時，沒法進行抉擇應該向哪一個A進行轉換。正確的作法是：

複製代碼代碼以下:

int main()
{
     D *pD = new D;
     B *pB = dynamic_cast<B *>(pD);
     A *pA = dynamic_cast<A *>(pB);
}

這就是我在實現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屬性移除。常量指針被轉換成很是量指針，而且仍然指向原來的對象；常量引用被轉換成很是量引用，而且仍然引用原來的對象。看如下的代碼例子：

複製代碼代碼以下:

/*
** FileName     : ConstCastDemo
** Author       : Jelly Young
** Date         : 2013/12/27
** Description  : More information, please go to http://www.jb51.net
*/
#include <iostream>
using namespace std;
class CA
{
public:
     CA():m_iA(10){}
     int m_iA;
};
int main()
{
     const CA *pA = new CA;
     // pA->m_iA = 100; // Error
     CA *pB = const_cast<CA *>(pA);
     pB->m_iA = 100;
     // Now the pA and the pB points to the same object
     cout<<pA->m_iA<<endl;
     cout<<pB->m_iA<<endl;
     const CA &a = *pA;
     // a.m_iA = 200; // Error
     CA &b = const_cast<CA &>(a);
     pB->m_iA = 200;
     // Now the a and the b reference to the same object
     cout<<b.m_iA<<endl;
     cout<<a.m_iA<<endl;
}

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

reinterpret_cast

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

容許將任何指針類型轉換爲其它的指針類型；聽起來很強大，可是也很不靠譜。它主要用於將一種數據類型從一種類型轉換爲另外一種類型。它能夠將一個指針轉換成一個整數，也能夠將一個整數轉換成一個指針，在實際開發中，先把一個指針轉換成一個整數，在把該整數轉換成原類型的指針，還能夠獲得原來的指針值；特別是開闢了系統全局的內存空間，須要在多個應用程序之間使用時，須要彼此共享，傳遞這個內存空間的指針時，就能夠將指針轉換成整數值，獲得之後，再將整數值轉換成指針，進行對應的操做。

總結

這篇博文總結了C++中的類型轉換，重點總結了其中的顯式轉換。對於C++支持的這四種顯式轉換都進行了詳細的描述。若是你們有什麼補充的，或者我總結的有誤的地方，請你們多多指教。