c++ 數據類型轉換： static_cast dynamic_cast reinterpret_cast const_cast

 1 #include<iostream>
 2 using namespace std;
 3 
 4 class father
 5 {
 6 public:
 7     void fun1()
 8     {
 9         cout<<"this is father fun1 call\n";
10     }
11     virtual void fun()
12     {
13         cout<<"this is father fun call\n";
14     }
15 };
16 
17 class son: public father
18 {
19 public:
20     void fun2()
21     {
22         cout<<"this is son fun2 call\n";
23     }
24     void fun()
25     {
26         cout<<"this is the son fun call\n";
27     }
28     int k;
29 };
30 
31 int main()
32 {
33     father *pf, f;
34     son *ps, s;
35 
36     pf = &f;// 基類的指針指向基類對象
37     ps = static_cast<son *>(pf);//這種轉換是不安全的，行爲是不肯定的
38     if(ps != NULL)
39     {
40         ps->fun(); //在本文編譯環境下，執行父類的fun
41         //本文編譯環境下，一下語句能夠執行
42         ps->fun2();
43         ps->k = 1;
44     }
45     ps = dynamic_cast<son *>(pf);//轉換後ps = NULL
46     if(ps == NULL)
47         cout<<"dynamic_cast: ps = NULL\n";
48     cout<<"-----------------------------------------------------------------\n";
49     pf = &s; //基類指針開始指向子類對象
50     //此時，兩種轉換都是安全的
51     ps = static_cast<son *>(pf);
52     if(ps != NULL)
53     {
54         ps->fun();
55         ps->fun2();
56         ps->k = 1;
57     }
58     ps = dynamic_cast<son *>(pf);//轉換後ps = NULL
59     if(ps != NULL)
60     {
61         ps->fun();
62         ps->fun2();
63         ps->k = 2;
64     }
65 }

結果：

舉例：上行轉換（把子類的指針或引用轉換成基類表示）

 1 //類定義同上
 2 int main()
 3 {
 4     father *pf, f;
 5     son *ps, s;
 6 
 7     ps = &s;// 子類的指針指向子類對象
 8     //此時兩種轉換都是安全的
 9     pf = static_cast<father *>(ps);
10     if(pf != NULL)
11     {
12         pf->fun();
13     }
14     pf = dynamic_cast<father *>(ps);
15     if(pf != NULL)
16     {
17         pf->fun();
18     }
19 
20 }

舉例: static_cast 用於基本類型之間、基本類型指針和空指針間的轉換（不能用於基本類型指針之間轉換）。

注意：基本類型因爲表示數值範圍的不一樣，所以須要用戶保證轉換的安全。另外dynamic_cast不能用於此類轉換

 1 int main()
 2 {
 3     //基本類型間的轉換，須要用戶保證安全
 4     int a = 1000;
 5     char c = static_cast<char>(a);//不安全，1000超過了char的表示範圍
 6     cout<<c<<endl;//輸出空
 7     a = 49;
 8     c = static_cast<char>(a);//安全，輸出字符‘1’
 9     cout<<c<<endl;
10     //c = dynamic_cast<char>(a); 錯誤
11     cout<<"-----------------------------------------------------------------\n";
12     //void *和基本類型指針的轉換，須要用戶保證轉換安全
13     a = 49;
14     void *pv;
15     pv = &a;
16     int *pi = static_cast<int *>(pv);//void * 轉換爲int *
17     cout<<*pi<<endl; //輸出49
18     //pi = dynamic_cast<int *>(pv); 錯誤
19     char *pc = static_cast<char *>(pv);//void *轉char*
20     cout<<*pc<<endl;//輸出字符‘1’
21     void *pv2 = static_cast<void *>(pc);// char * 轉void *
22     cout<<*((char *)pv2)<<endl;////輸出字符‘1’
23 }

【3】reinterpret_cast

用法：reinterpret_cast<type-id> (exdivssion)

reinterpret_cast運算符是用來處理無關類型之間的轉換；它會產生一個新的值，這個值會有與原始參數（expressoin）有徹底相同的比特位。按照reinterpret的字面意思「從新解釋」，即對數據的比特位從新解釋。

IBM的C++指南裏明確告訴了咱們reinterpret_cast能夠，或者說應該在什麼地方用來做爲轉換運算符：

從指針類型到一個足夠大的整數類型
從整數類型或者枚舉類型到指針類型
從一個指向函數的指針到另外一個不一樣類型的指向函數的指針
從一個指向對象的指針到另外一個不一樣類型的指向對象的指針
從一個指向類函數成員的指針到另外一個指向不一樣類型的函數成員的指針
從一個指向類數據成員的指針到另外一個指向不一樣類型的數據成員的指針

總結來講：reinterpret_cast用在任意指針（或引用）類型之間的轉換；以及指針與足夠大的整數類型之間的轉換；從整數類型（包括枚舉類型）到指針類型，無視大小。

注意：static_cast 不能轉換掉exdivssion的const、volitale、或者__unaligned屬性。

msdn官方解釋：http://msdn.microsoft.com/en-us/library/e0w9f63b(v=vs.80).aspx

舉例：reinterpret_cast用法

 1 int main()
 2 {
 3    int a = 49;
 4    int *pi = &a;
 5    char *pc = reinterpret_cast<char*>(pi);//int * 到char *,用戶本身安全
 6    cout<<*pc<<endl; //輸出字符"1"
 7    unsigned long b = reinterpret_cast<unsigned long>(pc);//char * 轉 unsigned long
 8    cout<<b<<endl;//輸出pc指向地址（即a的地址）對應的整數
 9    int *pi2 = reinterpret_cast<int *>(b);//unsigned long 轉 int*
10    cout<<*pi2<<endl; //輸出49
11 }

【4】const_cast

用法：const_cast<type-id> (exdivssion)

該運算符用來修改類型的const、volatile、__unaligned屬性。除了const 、volatile、__unaligned修飾以外， type_id和exdivssion的類型是同樣的。

常量指針被轉化成很是量指針，而且仍然指向原來的對象；

常量引用被轉換成很是量引用，而且仍然指向原來的對象；常量對象被轉換成很是量對象。

msdn官方解釋：http://msdn.microsoft.com/en-us/library/bz6at95h(v=vs.80).aspx

舉例：const_cast用法

1 int main()
2 {
3    const int a = 100;
4    int *b = const_cast<int *>(&a);//const int * 轉int *
5    cout<<*b<<endl; //輸出100
6    cout<<&a<<" "<<b<<endl; //二者值相同，代表b指向a的地址，只是const屬性變了
7 }