溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
本篇內容主要講解“C++強制類型轉換的方式有哪些”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“C++強制類型轉換的方式有哪些”吧!
利用編譯器內置的轉換規則，或者用戶自定義的轉換構造函數以及類型轉換函數（這些都可以認為是已知的轉換規則）。
例如從 int 到 double、從派生類到基類、從type *到void *、從 double 到 Complex 等。
注：
type *是一個具體類型的指針，例如int *、double *、Student *等，它們都可以直接賦值給void *指針。
例如，malloc() 分配內存后返回的就是一個void *指針，我們必須進行強制類型轉換后才能賦值給指針變量。
隱式不能完成的類型轉換工作，就必須使用強制類型轉換
(new_type) expression
數據類型的本質：
這種「確定數據的解釋方式」的工作就是由數據類型（Data Type）來完成的。例如int a;表明，a 這份數據是整數，不能理解為像素、聲音、視頻等。
數據類型轉換的本質：
數據類型轉換，就是對數據所占用的二進制位做出重新解釋。
隱式類型轉換：編譯器可以根據已知的轉換規則來決定是否需要修改數據的二進制位
強制類型轉換：由于沒有對應的轉換規則，所以能做的事情僅僅是重新解釋數據的二進制位，但無法對數據的二進制位做出修正。
隱式類型轉換必須使用已知的轉換規則，雖然靈活性受到了限制，但是由于能夠對數據進行恰當地調整，所以更加安全（幾乎沒有風險）。
強制類型轉換能夠在更大范圍的數據類型之間進行轉換，例如不同類型指針（引用）之間的轉換、從 const 到非 const 的轉換、從 int 到指針的轉換（有些編譯器也允許反過來）等，這雖然增加了靈活性，但是由于不能恰當地調整數據，所以也充滿了風險，程序員要小心使用。
C風格的強制類型轉換統一使用()，而()在代碼中隨處可見，所以也不利于使用檢索工具定位強轉的代碼位置。
C++ 對類型轉換進行了分類，并新增了四個關鍵字來予以支持，它們分別是：
關鍵字 說明
static_cast 用于良性轉換，一般不會導致意外發生，風險很低。
const_cast 用于 const 與非 const、volatile 與非 volatile 之間的轉換。
reinterpret_cast 高度危險的轉換，這種轉換僅僅是對二進制位的重新解釋，不會借助已有的轉換規則對數據進行調整，但是可以實現最靈活的 C++ 類型轉換。
dynamic_cast 借助 RTTI，用于類型安全的向下轉型（Downcasting）。
語法格式為： xxx_cast<newType>(data)
static_cast 是“靜態轉換”的意思，也就是在編譯期間轉換，轉換失敗的話會拋出一個編譯錯誤。
舉個例子：
#include <iostream>
#include <cstdlib>
using namespace std;
class Complex{
public:
Complex(double real = 0.0, double imag = 0.0): m_real(real), m_imag(imag){ }
public:
operator double() const { return m_real; } //類型轉換函數
private:
double m_real;
double m_imag;
};
int main(){
//下面是正確的用法
int m = 100;
Complex c(12.5, 23.8);
long n = static_cast<long>(m); //寬轉換，沒有信息丟失
char ch = static_cast<char>(m); //窄轉換，可能會丟失信息
int *p1 = static_cast<int*>( malloc(10 * sizeof(int)) ); //將void指針轉換為具體類型指針
void *p2 = static_cast<void*>(p1); //將具體類型指針，轉換為void指針
double real= static_cast<double>(c); //調用類型轉換函數
//下面的用法是錯誤的
float *p3 = static_cast<float*>(p1); //不能在兩個具體類型的指針之間進行轉換
p3 = static_cast<float*>(0X2DF9); //不能將整數轉換為指針類型
return 0;
}reinterpret_cast 用于進行各種不同類型的指針之間、不同類型的引用之間以及指針和能容納指針的整數類型之間的轉換。轉換時，執行的是逐個比特復制的操作。
#include <iostream>
using namespace std;
class A
{
public:
int i;
int j;
A(int n):i(n),j(n) { }
};
int main()
{
A a(100);
int &r = reinterpret_cast<int&>(a); //強行讓 r 引用 a
r = 200; //把 a.i 變成了 200
cout << a.i << "," << a.j << endl; // 輸出 200,100
int n = 300;
A *pa = reinterpret_cast<A*> ( & n); //強行讓 pa 指向 n
pa->i = 400; // n 變成 400
pa->j = 500; //此條語句不安全，很可能導致程序崩潰
cout << n << endl; // 輸出 400
long long la = 0x12345678abcdLL;
pa = reinterpret_cast<A*>(la); //la太長，只取低32位0x5678abcd拷貝給pa
unsigned int u = reinterpret_cast<unsigned int>(pa);//pa逐個比特拷貝到u
cout << hex << u << endl; //輸出 5678abcd
typedef void (* PF1) (int);
typedef int (* PF2) (int,char *);
PF1 pf1; PF2 pf2;
pf2 = reinterpret_cast<PF2>(pf1); //兩個不同類型的函數指針之間可以互相轉換
}reinterpret_cast體現了 C++ 語言的設計思想：用戶可以做任何操作，但要為自己的行為負責。
const_cast 運算符僅用于進行去除 const 屬性的轉換，它也是四個強制類型轉換運算符中唯一能夠去除 const 屬性的運算符。
將 const 引用轉換為同類型的非 const 引用，將 const 指針轉換為同類型的非 const 指針時可以使用 const_cast 運算符。例如：
const string s = "Inception"; string& p = const_cast <string&> (s); string* ps = const_cast <string*> (&s); // &s 的類型是 const string*
用 reinterpret_cast 可以將多態基類（包含虛函數的基類）的指針強制轉換為派生類的指針，但是這種轉換不檢查安全性，即不檢查轉換后的指針是否確實指向一個派生類對象。
dynamic_cast專門用于將多態基類的指針或引用強制轉換為派生類的指針或引用，而且能夠檢查轉換的安全性。對于不安全的指針轉換，轉換結果返回 NULL 指針。
dynamic_cast 用于在類的繼承層次之間進行類型轉換，它既允許向上轉型（Upcasting），也允許向下轉型（Downcasting）。向上轉型是無條件的，不會進行任何檢測，所以都能成功；向下轉型的前提必須是安全的，要借助 RTTI 進行檢測，所有只有一部分能成功。
dynamic_cast 與 static_cast 是相對的，dynamic_cast 是“動態轉換”的意思，static_cast 是“靜態轉換”的意思。dynamic_cast 會在程序運行期間借助 RTTI 進行類型轉換，這就要求基類必須包含虛函數；static_cast 在編譯期間完成類型轉換，能夠更加及時地發現錯誤。
dynamic_cast 是通過“運行時類型檢查”來保證安全性的。
dynamic_cast 不能用于將非多態基類的指針或引用強制轉換為派生類的指針或引用——這種轉換沒法保證安全性，只好用 reinterpret_cast 來完成。
向上轉型時，只要待轉換的兩個類型之間存在繼承關系，并且基類包含了虛函數（這些信息在編譯期間就能確定），就一定能轉換成功。因為向上轉型始終是安全的，所以 dynamic_cast 不會進行任何運行期間的檢查，這個時候的 dynamic_cast 和 static_cast 就沒有什么區別了。
「向上轉型時不執行運行期檢測」雖然提高了效率，但也留下了安全隱患，請看下面的代碼：
#include <iostream>
#include <iomanip>
using namespace std;
class Base{
public:
Base(int a = 0): m_a(a){ }
int get_a() const{ return m_a; }
virtual void func() const { }
protected:
int m_a;
};
class Derived: public Base{
public:
Derived(int a = 0, int b = 0): Base(a), m_b(b){ }
int get_b() const { return m_b; }
private:
int m_b;
};
int main(){
//情況①
Derived *pd1 = new Derived(35, 78);
Base *pb1 = dynamic_cast<Derived*>(pd1);
cout<<"pd1 = "<<pd1<<", pb1 = "<<pb1<<endl;
cout<<pb1->get_a()<<endl;
pb1->func();
//情況②
int n = 100;
Derived *pd2 = reinterpret_cast<Derived*>(&n);
Base *pb2 = dynamic_cast<Base*>(pd2);
cout<<"pd2 = "<<pd2<<", pb2 = "<<pb2<<endl;
cout<<pb2->get_a()<<endl; //輸出一個垃圾值
pb2->func(); //內存錯誤
return 0;
}情況①是正確的，沒有任何問題。對于情況②，pd 指向的是整型變量 n，并沒有指向一個 Derived 類的對象，在使用 dynamic_cast 進行類型轉換時也沒有檢查這一點，而是將 pd 的值直接賦給了 pb（這里并不需要調整偏移量），最終導致 pb 也指向了 n。因為 pb 指向的不是一個對象，所以get_a()得不到 m_a 的值（實際上得到的是一個垃圾值），pb2->func()也得不到 func() 函數的正確地址。
pb2->func()得不到 func() 的正確地址的原因在于，pb2 指向的是一個假的“對象”，它沒有虛函數表，也沒有虛函數表指針，而 func() 是虛函數，必須到虛函數表中才能找到它的地址。
向下轉型是有風險的，dynamic_cast 會借助 RTTI 信息進行檢測，確定安全的才能轉換成功，否則就轉換失敗。那么，哪些向下轉型是安全地呢，哪些又是不安全的呢？下面我們通過一個例子來演示：
#include <iostream>
using namespace std;
class A{
public:
virtual void func() const { cout<<"Class A"<<endl; }
private:
int m_a;
};
class B: public A{
public:
virtual void func() const { cout<<"Class B"<<endl; }
private:
int m_b;
};
class C: public B{
public:
virtual void func() const { cout<<"Class C"<<endl; }
private:
int m_c;
};
class D: public C{
public:
virtual void func() const { cout<<"Class D"<<endl; }
private:
int m_d;
};
int main(){
A *pa = new A();
B *pb;
C *pc;
//情況①
pb = dynamic_cast<B*>(pa); //向下轉型失敗
if(pb == NULL){
cout<<"Downcasting failed: A* to B*"<<endl;
}else{
cout<<"Downcasting successfully: A* to B*"<<endl;
pb -> func();
}
pc = dynamic_cast<C*>(pa); //向下轉型失敗
if(pc == NULL){
cout<<"Downcasting failed: A* to C*"<<endl;
}else{
cout<<"Downcasting successfully: A* to C*"<<endl;
pc -> func();
}
cout<<"-------------------------"<<endl;
//情況②
pa = new D(); //向上轉型都是允許的
pb = dynamic_cast<B*>(pa); //向下轉型成功
if(pb == NULL){
cout<<"Downcasting failed: A* to B*"<<endl;
}else{
cout<<"Downcasting successfully: A* to B*"<<endl;
pb -> func();
}
pc = dynamic_cast<C*>(pa); //向下轉型成功
if(pc == NULL){
cout<<"Downcasting failed: A* to C*"<<endl;
}else{
cout<<"Downcasting successfully: A* to C*"<<endl;
pc -> func();
}
return 0;
}當使用 dynamic_cast 對指針進行類型轉換時，程序會先找到該指針指向的對象，再根據對象找到當前類（指針指向的對象所屬的類）的類型信息，并從此節點開始沿著繼承鏈向上遍歷，如果找到了要轉化的目標類型，那么說明這種轉換是安全的，就能夠轉換成功，如果沒有找到要轉換的目標類型，那么說明這種轉換存在較大的風險，就不能轉換。
對于本例中的情況①，pa 指向 A 類對象，根據該對象找到的就是 A 的類型信息，當程序從這個節點開始向上遍歷時，發現 A 的上方沒有要轉換的 B 類型或 C 類型（實際上 A 的上方沒有任何類型了），所以就轉換敗了。對于情況②，pa 指向 D 類對象，根據該對象找到的就是 D 的類型信息，程序從這個節點向上遍歷的過程中，發現了 C 類型和 B 類型，所以就轉換成功了。
總起來說，dynamic_cast 會在程序運行過程中遍歷繼承鏈，如果途中遇到了要轉換的目標類型，那么就能夠轉換成功，如果直到繼承鏈的頂點（最頂層的基類）還沒有遇到要轉換的目標類型，那么就轉換失敗。對于同一個指針（例如 pa），它指向的對象不同，會導致遍歷繼承鏈的起點不一樣，途中能夠匹配到的類型也不一樣，所以相同的類型轉換產生了不同的結果。
從表面上看起來 dynamic_cast 確實能夠向下轉型，本例也很好地證明了這一點：B 和 C 都是 A 的派生類，我們成功地將 pa 從 A 類型指針轉換成了 B 和 C 類型指針。但是從本質上講，dynamic_cast 還是只允許向上轉型，因為它只會向上遍歷繼承鏈。造成這種假象的根本原因在于，派生類對象可以用任何一個基類的指針指向它，這樣做始終是安全的。本例中的情況②，pa 指向的對象是 D 類型的，pa、pb、pc 都是 D 的基類的指針，所以它們都可以指向 D 類型的對象，dynamic_cast 只是讓不同的基類指針指向同一個派生類對象罷了。
到此，相信大家對“C++強制類型轉換的方式有哪些”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
