C++的類型轉換

C++類型轉換

類型轉換機制可以分為:隱式類型轉換 和 顯示類型轉換(強制類型轉換)

在C中我們這樣做類型轉換：

float a=1.023
int b;
b=a; //隱式類型轉換
或
b=int(a); //顯式類型轉換
或
b=(int)a;

C++中的類型轉換：
隱式類型轉換比較常見,在混合類型表達式中經常發生.比如在表達式中存在short和int,那么就過會發生整型提升.四種強制類型轉換操作符：static_cast、dynamic_cast、const_cast、reinterpret_cast。

1、static_cast與dynamic_cast:
前者提供的是編譯時期的靜態類型檢測,后者提供的是運行時檢測.
static_cast： 1）完成基礎數據類型，2）同一個繼承體系中類型的轉換 3）任意類型與空指針類型void*之間的轉換。
dynamic_cast：使用多態的場景，增加了一層對真實調用對象類型的檢查

     char c  = 65;
     int *p = (int *)&c;
     cout<<(char)*p<<endl;//'A'
     *p = 5;
     int *q = static_cast<int *>(&c); //編譯報錯:error: invalid static_cast from type ‘char*’ to type ‘int*’

　　在上面的例子中,Clike可以運行,然而修改過的*p如果使用,運行結果將會出現錯誤,而使用static_cast可以將錯誤在編譯時期檢查出
在不同繼承體系的自定義類型中:

class A
{
public:
  A(){}
  ~A(){}

private:
  int i, j;
};

class C
{
public:
  C(){}
  ~C(){}

  void printC()
  {
    std::cout <<"call printC() in class C" <<std::endl;
  }
private:
  char c1, c2;
};     

    A *ptrA = new A();
     C *ptrC = (C *)(ptrA);
     ptrC->printC(); //"call printC() in class C"
     //ptrC = static_cast<C*>(ptrA); //編譯報錯:error: invalid static_cast from type 'A*’ to type C*

　　上面A C是兩個無關的類,然而使用Clike可以實現這種類型的強制轉換,這是十分危險的! 使用static_cast可以將這種潛在的危險在編譯器找出來.

　　在同一繼承體系中:

　　upcast(向上轉換即子類轉成父類):沒有問題.因為父類的行為都包含在子類中;

　　downcast(向下轉換):有可能會出現問題,編譯時可能不會發現.

　　一個類的行為和自身的類型相關.也就是一個A類型的指針總會優先調用自己A類內的函數,當然發生繼承中的重寫(虛繼承等)例外.

#include <iostream>
#include <cstdio>

using namespace std;
class A
{
public:
  A():i(1), j(1){}
  ~A(){}

  void printA()
  {
    std::cout <<"call printA() in class A" <<std::endl;
  }

  void printSum()
  {
    std::cout <<"sum = " <<i+j <<std::endl;
  }

private:
  int i, j;
};

class B : public A
{
public:
  B():a(2), b(2) {}
  ~B(){}

  void printB()
  {
    std::cout <<"call printB() in class B" <<std::endl;
  }

  void printSum()
  {
    std::cout <<"sum = " <<a+b <<std::endl;
  }

  void Add()
  {
    a++;
    b++;
  }

private:
  double a, b;
};
int main()
{
     B *ptrB = new B;
     ptrB -> printSum();
     A *ptrA = static_cast<B *>(ptrB);
     ptrA -> printA();
     ptrA -> printSum();
     //打印結果：sum = 2
     //在進行upcast的時候，指針指向的對象的行為與指針的類型相關。

     ptrA = new A;
     ptrB = static_cast<B *>(ptrA);
     ptrB -> printB();
     ptrB -> printSum();
     //打印結果：sum = 0
     //在進行downcast的時候，其行為是“undefined”。

     B b;
     B &rB = b;
     rB.printSum();
     //打印結果: sum = 4
     A &rA = static_cast<A &>(b);
     rA.printA();
     rA.printSum();
     //打印結果: sum = 2
     //在進行upcast的時候,指針指向的對象的行為與引用類型相關.

     A a;
     A &rA1 = a;
     rA.printSum();
     B &rB1 = static_cast<B &>(a);
     rB1.printB();
　　　//打印結果：sum = 4 
     rB1.printSum();
     //打印結果 :sum = 1.45863e-316
     //在進行downcast的時候，其行為是“undefined”。

     return 0;
}

　　這里其實很明顯,在downcast轉換的時候,會出現一些跟指針或者引用類型相關的函數調用,但是因為指針或者引用(父類)

reinterpret_cast
僅僅是復制n1的比特位到d_r, 沒有進行必要的分析.interpret_cast是為了映射到一個完全不同類型\
的意思，這個關鍵詞在我們需要把類型映射回原有類型時用到它。我們映射到的類型僅僅是為了故弄\
玄虛和其他目的，這是所有映射中最危險的。(這句話是C++編程思想中的原話

const_cast
去除const常量屬性，使其可以修改volatile屬性的轉換 易變類型<->不同類型.

#include <iostream>
#include <cstdio>
#include <string>

using namespace std;

class A {
    public:
    A(){};
    int m_a;
};

class B {
    public:
    int m_b;
};

class C : public A, public B {};

int main()
{
    const A a;
    //a.num = 1;
    const_cast<A&>(a).m_a = 2;
    //a.num = 3;編譯不能通過，說明const_cast只能轉換一次，不是永久脫離原有const屬性
    cout<<a.m_a<<endl;
    int n = 9;
    double d_s = static_cast<double>(n);
    double d_r = reinterpret_cast<double&>(n);
    cout<<d_r<<endl;//4.24399e-314
    //在進行計算以后, d_r包含無用值. 這是因為 reinterpret_cast僅僅是復制n1的比特位到d_r, 沒有進行必要的分析.interpret_cast是為了映射到一個完全不同類型的意思，這個關鍵詞在我們需要把類型映射回原有類型時用到它。我們映射到的類型僅僅是為了故弄玄虛和其他目的，這是所有映射中最危險的。(這句話是C++編程思想中的原話
    return 0;
}

#include <iostream>
#include <typeinfo>
#include <cstdio>

using namespace std;

class A{
public:
virtual void foo(){
cout<<"A foo"<<endl;
}
//虛函數的出現會帶來動態機制 Class A 至少要有一個虛函數
void pp(){
cout<<"A pp"<<endl;
}
};

class B: public A{
public:
void foo(){
cout<<"B foo"<<endl;
}
void pp(){
cout<<"B PP"<<endl;
}
void functionB(){
cout<<"Excute FunctionB!"<<endl;
}
};

int main()
{
B b;
A pa = &b;
pa->foo();
pa->pp();
//基類指針可以指向派生類，但是只能調用基類和派生類都存在的成員，也就是說不能調用派生類中新增的成員！
//pa->FunctionB();//error: 'class A' has no member named 'FunctionB'
if(dynamic_cast<B>(pa) == NULL){
cout<<"NULL"<<endl;
}else{
cout<<typeid((dynamic_cast<B>(pa))).name()<<endl;
dynamic_cast<B>(pa)->foo();
dynamic_cast<B>(pa)->pp();
dynamic_cast<B>(pa)->functionB();
}
A aa;
//B pb = &aa;派生類不能指向基類
B pbNull = NULL;
pbNull->functionB();//fine
pbNull->pp();//fine
//pbNull->functionB(); crash！foo調用了虛函數，編譯器需要根據對象的虛函數指針查找虛函數表，但為空，crash!
return 0;
}