C++強制類型轉換

C++強制類型轉換：static_cast、dynamic_cast、const_cast、reinterpret_cast

C強制轉換

　　C語言中的強制轉換主要用於普通數據類型、指針的強制轉換，沒有類型檢查，轉換不安全，語法為：

(type-id)expression//轉換格式1
type-id(expression)//轉換格式2

　　C++除了能使用c語言的強制類型轉換外，還新增了四種強制類型轉換：static_cast、dynamic_cast、const_cast、reinterpret_cast，主要運用於繼承關系類間的強制轉化，語法為：

//靜態轉換
static_cast<new_type>      (expression)
//動態轉換
dynamic_cast<new_type>     (expression) 
//常量轉換
const_cast<new_type>       (expression) 
//重新解釋轉換
reinterpret_cast<new_type> (expression)

　　其中new type為轉換后的新類型，expression為舊類型

C++強制類型轉換

1. static_cast 靜態轉換（編譯時檢查）

　　static_cast靜態轉換相當於C語言中的強制轉換，但不能實現普通指針數據（空指針除外）的強制轉換，一般用於父類和子類指針、引用間的相互轉換。

　　①用於類層次結構中基類（父類）和派生類（子類）之間指針或引用的轉換。不管是否發生多態，父子之間互轉時，編譯器都不會報錯。

　　　　進行上行轉換（把派生類的指針或引用轉換成基類表示）是安全的；

　　　　進行下行轉換（把基類指針或引用轉換成派生類表示）時，由於沒有動態類型檢查，所以是不安全的，但是編譯器不會報錯。

　　②用於基本數據類型之間的轉換，如把int轉換成char，把int轉換成enum。這種轉換的安全性也要開發人員來保證。

　　③把空指針轉換成目標類型的空指針。

　　④把任何指針類型轉換成空指針類型。

　　⑤可以對普通數據的const和non_const進行轉換，但不能對普通數據取地址后的指針進行const添加和消去。

　　⑥無繼承關系的自定義類型，不可轉換，不支持類間交叉轉換。

　　注意：static_cast不能轉換掉expression的const、volatile、或者__unaligned屬性

class Person{

};

class Son :public Person{

};

class My{};

void test02(){
    char a = 'c';
    int b = static_cast<int> (a);
    cout << b << endl;

    const char a0 = 'c';
    char b0 = static_cast<char> (a0);
    cout << b0 << endl;

    char a1 = 'c';
    const char b1 = static_cast<const char> (a1);
    cout << b1 << endl;

    //static無法丟掉常量或其他類型限定符，只限於對常量地址的指針去const
    //const char a2 = 'c';
    //char *b2 = static_cast<char*> (&a2);
    //cout << b2 << endl;

    
    //父類指針轉為子類
    Person *p = NULL;
    Son *s = static_cast<Son*>(p);

    //子類指針轉為父類
    Son *s0 = NULL;
    Person *p0 = static_cast<Person*>(s0);

    //My* my= static_cast<My*>(p); 無繼承關系的自定義數據類型不能相互轉換

    //父類對象無法轉為子類對象
    //Person p1;
    //Son s1 = static_cast<Son>(p1);
    
    //子類對象可以賦值，初始化父類對象
    Son s2;
    Person p2 = static_cast<Person>(s2);

    //父類引用轉為子類
    Person p_ ;
    Person &p3 = p_;
    Son &s3 = static_cast<Son&>(p3);

    //子類引用轉為父類
    Son s_;
    Son &s4 = s_;
    Person &p4 = static_cast<Person&>(s4);

    //空指針轉化為目標類型的指針
    void *pPtr = NULL;
    int *iPtr = static_cast<int*>(pPtr);

    //任何指針轉化為空指針類型
    int *aInt = NULL;
    void *aVoid = static_cast<void*>(aInt);

    //static_cast不能進行出void外的指針強制互轉
    char *tmp = "abc";
    cout << tmp << endl;

    //cout << static_cast<int*>(tmp) << endl;不能將char*型的數據轉換為int*，但C語言強轉可以
    cout << static_cast<void*>(tmp) << endl;

    int *tmp_ = (int*)(tmp); 
    cout << static_cast<int*>(tmp_) << endl;

    int *tmpInt = 0;
    cout << tmpInt << endl;
    cout << static_cast<void*>(tmpInt) << endl;
    cout << static_cast<int*>(tmpInt) << endl;//轉為自身可以
}

2.dynamic_cast 動態轉換（運行時檢查）

　　動態轉換的類型和操作數必須是完整類類型或空指針、空引用，說人話就是說，只能用於類間轉換，支持類間交叉轉換，不能操作普通數據。

　　主要用於類層次結構中基類（父類）和派生類（子類）之間指針或引用的轉換，

　　　　①進行上行轉換（把派生類的指針或引用轉換成基類表示）是安全的，允許轉換；

　　　　②進行下行轉換（把基類指針或引用轉換成派生類表示）時，由於沒有動態類型檢查，所以是不安全的，不允許轉化，編譯器會報錯；

　　　　③發生多態時，允許互相轉換。

　　　　④無繼承關系的類之間也可以相互轉換，類之間的交叉轉換。

　　　　⑤如果dynamic_cast語句的轉換目標是指針類型並且失敗了，則結果為0。如果轉換目標是引用類型並且失敗了，則dynamic_cast運算符將拋出一個std::bad_cast異常

3. const_cast 常量轉換

　　const_cast，用於修改類型的const或volatile屬性，不能對非指針或非引用的變量添加或移除const。

const int g = 20;
//int h = const_cast<int>(g); //不允許對普通數據進行操作
int *h = const_cast<int*>(&g);//去掉const常量const屬性

const int g0 = 20;
const int &g2 = g0;
int &h = const_cast<int &>(g0);//去掉const引用const屬性
int &h2 = const_cast<int &>(g2);//去掉const引用const屬性

const char *g1 = "hello";
char *h = const_cast<char *>(g1);//去掉const指針const屬性

4.reinterpret_cast 重新解釋轉換

　　最雞肋的轉換函數，可以將任意類型轉換為任意類型，因此非常不安全。只有將轉換后的類型值轉換回到其原始類型，這樣才是正確使用reinterpret_cast方式。

　　另外，static_cast和reinterpret_cast的區別主要在於多重繼承，比如

class A {
    public:
    int m_a;
};
 
class B {
    public:
    int m_b;
};
 
class C : public A, public B {};

void test(){
    C c;
    printf("%p, %p, %p", &c, reinterpret_cast<B*>(&c), static_cast <B*>(&c));
}

　　前兩個的輸出值是相同的，最后一個則會在原基礎上偏移4個字節，這是因為static_cast計算了父子類指針轉換的偏移量，並將之轉換到正確的地址（c里面有m_a,m_b，轉換為B*指針后指到m_b處），而reinterpret_cast卻不會做這一層轉換