淺談C++的類型轉換

C++是強類型語言，也就是說，變量在使用前就要聲明數據類型，不同數據類型分配的內存空間大小也是不同，在轉換類型時要注意這個問題，防止數據丟失或越界溢出。文章將簡單討論一下C++的類型轉換。

C++從C發展而來，也繼承兩種C風格的轉換：隱式轉換和顯式轉換。

隱式轉換
隱式轉換是指由編譯系統自動進行，不需要人工干預的類型轉換，例如：

short a = 2000;
int b;
b = a;

隱式轉換，也包括構造函數和運算符的轉換，例如：

class A {};
class B {
public: 
   B (A a) {}
};

A a;
B b = a;

顯式轉換

和隱式轉換相反，顯式轉換要利用強制類型轉換運算符進行轉換，例如：

double x = 10.3;
int y;
y = int (x);    // 函數式寫法
y = (int) x;    // C風格寫法

以上類型轉換已經滿足了基本類型的轉換了。但是如果想轉換類和指針，有時代碼可以編譯，在運行過程中會出錯。例如：

#include <iostream>

class CDummy {
    float i,j;
public:
    CDummy () { i=1; j=1; }
};

class CAddition {
    int x,y;
public:
    CAddition () { x=1; y=1; }
    int result() { return x+y;}
};

int main () {
  CDummy d;
  CAddition * padd;
  padd = (CAddition*) &d;
  std::cout << padd->result();
  return 0;
}

這段代碼會在運行期出錯，在執行padd->result()時發生異常，有些編譯器會異常退出。
傳統明確的類型轉換，可以轉換成任何其他指針類型任何指針，它們指向的類型無關。在隨后的調用成員的結果，會產生一個運行時錯誤或意外的結果。

/********  無情的分割線 ********* / 
  作者：沒有開花的樹 
  博客：blog.csdn.net/mycwq 
/ *******   無情的copy  *********/  

C++標準轉換運算符
傳統的類和指針的類型轉換方式很不安全，可能會在運行時異常退出，標準C++ 提供了四個轉換運算符：dynamic_cast、reinterpret_cast、static_cast、 const_cast

dynamic_cast <new_type> (expression)
reinterpret_cast <new_type> (expression)
static_cast <new_type> (expression)
const_cast <new_type> (expression)

dynamic_cast
dynamic_cast只能用于指針和引用的對象。其目的是確保類型轉換的結果是一個有效的完成所請求的類的對象，所以當我們從一個類轉換到這個類的父類，dynamic_cast總是可以成功。dynamic_cast 可以轉換NULL指針為不相關的類，也可以任何類型的指針為void指針。 

class CBase { };
class CDerived: public CBase { };
CBase b;
CDerived d;

CBase* pb = dynamic_cast<CBase*>(&d);        // 子類轉父類，正確
CDerived* pd = dynamic_cast<CDerived*>(&b);  // 父類轉子類，錯誤

當新的類型不是被轉換的類型的父類，dynamic_cast無法完成指針的轉換，返回NULL。當dynamic_cast轉換引用類型時，遇到失敗會拋出Bad_cast 異常。

 

static_cast
static_cast可以執行相關的類的指針之間的轉換，可以在子類和父類之間相互轉換，但父類指針轉成子類指針是不安全的。static_cast沒有在運行時進行安全檢查，因此我們要先確保轉換是安全的。另一方面，static_cast對比dynamic_cast少了在類型安全檢查的開銷。

class CBase {};
class CDerived: public CBase {};
CBase * a = new CBase;
CDerived * b = static_cast<CDerived*>(a);

上述代碼是合法的，b指向一個不完整的對象，可能在運行期導致錯誤。
static_cast也可以用來執行任何其他非指針的轉換，如基本類型enum, struct, int, char, float等之間的標準轉換：

double d = 3.14159265;
int i = static_cast<int>(d); 
void* p = static_cast<void*>(&i); //任意類型轉換成void類型

 

reinterpret_cast
reinterpret_cast轉換成任何其他指針類型，甚至無關的類，任何指針類型。操作的結果是重新解釋類型，但沒有進行二進制的轉換。所有的指針轉換是允許的：不管是指針指向的內容還是指針本身的類型。

class A {};
class B {};
A * a = new A;
B * b = reinterpret_cast<B*>(a)

reinterpret_cast還可以用來轉換函數指針類型，例如：

typedef void(*Func)();                 // 聲明一種函數指針定義，返回void
Func pFunc;                            // 定義FuncPtr類型的數組

pFunc = &test;                         // 編譯錯誤！類型不匹配
pFunc = reinterpret_cast<Func>(&test); // 編譯成功！轉換函數指針類型

const_cast
const_cast用于操縱對象的常量性，去掉類型的const或volatile屬性。

#include <iostream>

void print (char * str){
  std::cout << str ;
}

int main () {
  const char* c = "hello world";
  print ( const_cast<char *> (c) );
  return 0;
}

參考：

http://blog.csdn.net/mycwq/article/details/17300973
http://www.cnblogs.com/ggjucheng/archive/2012/01/04/2311650.html
http://www.cplusplus.com/doc/tutorial/typecasting/
來自：http://blog.csdn.net/mycwq/article/details/17300973