在 C/C++ 中經常會發生數據類型的轉換，例如將 int 類型的數據賦值給 float 類型的變量時，編譯器會先把 int 類型的數據轉換為 float 類型再賦值；反過來，float 類型的數據在經過類型轉換後也可以賦值給 int 類型的變量。
數據類型轉換的前提是，編譯器知道如何對數據進行取捨。例如：
int a = 10.9;
printf("%d\n", a);
輸出結果為 10，編譯器會將小數部分直接丟掉（不是四捨五入）。再如：
float b = 10;
printf("%f\n", b);
輸出結果為 10.000000，編譯器會自動添加小數部分。
類其實也是一種數據類型，也可以發生數據類型轉換，不過這種轉換只有在基類和派生類之間才有意義，並且只能將派生類賦值給基類，包括將派生類對象賦值給基類對象、將派生類指針賦值給基類指針、將派生類引用賦值給基類引用，這在 C++ 中稱為向上轉型（Upcasting）。相應地，將基類賦值給派生類稱為向下轉型（Downcasting）。
向上轉型非常安全，可以由編譯器自動完成；向下轉型有風險，需要程序員手動干預。本節只介紹向上轉型，向下轉型將在後續章節介紹。
向上轉型和向下轉型是面向對象編程的一種通用概念，它們也存在於 Java、C# 等編程語言中。
將派生類對象賦值給基類對象
下面的例子演示了如何將派生類對象賦值給基類對象：
#include <iostream>
using namespace std;
//基類
class A{
public:
A(int a);
public:
void display();
public:
int m_a;
};
A::A(int a): m_a(a){ }
void A::display(){
cout<<"Class A: m_a="<<m_a<<endl;
}
//派生類
class B: public A{
public:
B(int a, int b);
public:
void display();
public:
int m_b;
};
B::B(int a, int b): A(a), m_b(b){ }
void B::display(){
cout<<"Class B: m_a="<<m_a<<", m_b="<<m_b<<endl;
}
int main(){
A a(10);
B b(66, 99);
//賦值前
a.display();
b.display();
cout<<"--------------"<<endl;
//賦值後
a = b;
a.display();
b.display();
return 0;
}
運行結果：
Class A: m_a=10
Class B: m_a=66, m_b=99
----------------------------
Class A: m_a=66
Class B: m_a=66, m_b=99
本例中 A 是基類， B 是派生類，a、b 分別是它們的對象，由於派生類 B 包含了從基類 A 繼承來的成員，因此可以將派生類對象 b 賦值給基類對象 a。通過運行結果也可以發現，賦值後 a 所包含的成員變量的值已經發生了變化。
賦值的本質是將現有的數據寫入已分配好的內存中，對象的內存只包含了成員變量，所以對象之間的賦值是成員變量的賦值，成員函數不存在賦值問題。運行結果也有力地證明了這一點，雖然有
a=b;這樣的賦值過程，但是 a.display() 始終調用的都是 A 類的 display() 函數。換句話說，對象之間的賦值不會影響成員函數，也不會影響 this 指針。
將派生類對象賦值給基類對象時，會捨棄派生類新增的成員，也就是“大材小用”，如下圖所示：
可以發現，即使將派生類對象賦值給基類對象，基類對象也不會包含派生類的成員，所以依然不同通過基類對象來訪問派生類的成員。對於上面的例子，a.m_a 是正確的，但 a.m_b 就是錯誤的，因為 a 不包含成員 m_b。
這種轉換關系是不可逆的，只能用派生類對象給基類對象賦值，而不能用基類對象給派生類對象賦值。理由很簡單，基類不包含派生類的成員變量，無法對派生類的成員變量賦值。同理，同一基類的不同派生類對象之間也不能賦值。
要理解這個問題，還得從賦值的本質入手。賦值實際上是向內存填充數據，當數據較多時很好處理，捨棄即可；本例中將 b 賦值給 a 時（執行
a=b;語句），成員 m_b 是多余的，會被直接丟掉，所以不會發生賦值錯誤。但當數據較少時，問題就很棘手，編譯器不知道如何填充剩下的內存；如果本例中有
b= a;這樣的語句，編譯器就不知道該如何給變量 m_b 賦值，所以會發生錯誤。
將派生類指針賦值給基類指針
除了可以將派生類對象賦值給基類對象（對象變量之間的賦值），還可以將派生類指針賦值給基類指針（對象指針之間的賦值）。我們先來看一個多繼承的例子，繼承關系為：
下面的代碼實現了這種繼承關系：
#include <iostream>
using namespace std;
//基類A
class A{
public:
A(int a);
public:
void display();
protected:
int m_a;
};
A::A(int a): m_a(a){ }
void A::display(){
cout<<"Class A: m_a="<<m_a<<endl;
}
//中間派生類B
class B: public A{
public:
B(int a, int b);
public:
void display();
protected:
int m_b;
};
B::B(int a, int b): A(a), m_b(b){ }
void B::display(){
cout<<"Class B: m_a="<<m_a<<", m_b="<<m_b<<endl;
}
//基類C
class C{
public:
C(int c);
public:
void display();
protected:
int m_c;
};
C::C(int c): m_c(c){ }
void C::display(){
cout<<"Class C: m_c="<<m_c<<endl;
}
//最終派生類D
class D: public B, public C{
public:
D(int a, int b, int c, int d);
public:
void display();
private:
int m_d;
};
D::D(int a, int b, int c, int d): B(a, b), C(c), m_d(d){ }
void D::display(){
cout<<"Class D: m_a="<<m_a<<", m_b="<<m_b<<", m_c="<<m_c<<", m_d="<<m_d<<endl;
}
int main(){
A *pa = new A(1);
B *pb = new B(2, 20);
C *pc = new C(3);
D *pd = new D(4, 40, 400, 4000);
pa = pd;
pa -> display();
pb = pd;
pb -> display();
pc = pd;
pc -> display();
cout<<"-----------------------"<<endl;
cout<<"pa="<<pa<<endl;
cout<<"pb="<<pb<<endl;
cout<<"pc="<<pc<<endl;
cout<<"pd="<<pd<<endl;
return 0;
}
運行結果：
Class A: m_a=4
Class B: m_a=4, m_b=40
Class C: m_c=400
-----------------------
pa=0x9b17f8
pb=0x9b17f8
pc=0x9b1800
pd=0x9b17f8
本例中定義了多個對象指針，並嘗試將派生類指針賦值給基類指針。與對象變量之間的賦值不同的是，對象指針之間的賦值並沒有拷貝對象的成員，也沒有修改對象本身的數據，僅僅是改變了指針的指向。
1) 通過基類指針訪問派生類的成員
請讀者先關注第 68 行代碼，我們將派生類指針 pd 賦值給了基類指針 pa，從運行結果可以看出，調用 display() 函數時雖然使用了派生類的成員變量，但是 display() 函數本身卻是基類的。也就是說，將派生類指針賦值給基類指針時，通過基類指針只能使用派生類的成員變量，但不能使用派生類的成員函數，這看起來有點不倫不類，究竟是為什麼呢？第 71、74 行代碼也是類似的情況。
pa 本來是基類 A 的指針，現在指向了派生類 D 的對象，這使得隱式指針 this 發生了變化，也指向了 D 類的對象，所以最終在 display() 內部使用的是 D 類對象的成員變量，相信這一點不難理解。
編譯器雖然通過指針的指向來訪問成員變量，但是卻不通過指針的指向來訪問成員函數：編譯器通過指針的類型來訪問成員函數。對於 pa，它的類型是 A，不管它指向哪個對象，使用的都是 A 類的成員函數，具體原因已在《C++函數編譯原理和成員函數的實現》中做了詳細講解。
概括起來說就是：編譯器通過指針來訪問成員變量，指針指向哪個對象就使用哪個對象的數據；編譯器通過指針的類型來訪問成員函數，指針屬於哪個類的類型就使用哪個類的函數。
2) 賦值後值不一致的情況
本例中我們將最終派生類的指針 pd 分別賦值給了基類指針 pa、pb、pc，按理說它們的值應該相等，都指向同一塊內存，但是運行結果卻有力地反駁了這種推論，只有 pa、pb、pd 三個指針的值相等，pc 的值比它們都大。也就是說，執行
pc = pd;語句後，pc 和 pd 的值並不相等。
這非常出乎我們的意料，按照我們通常的理解，賦值就是將一個變量的值交給另外一個變量，不會出現不相等的情況，究竟是什麼導致了 pc 和 pd 不相等呢？我們將在《派生類給基類賦值時到底發生了什麼》一節中解開謎底。
將派生類引用賦值給基類引用
引用在本質上是通過指針的方式實現的，這一點已在《引用在本質上是什麼，它和指針到底有什麼區別》中進行了講解，既然基類的指針可以指向派生類的對象，那麼我們就有理由推斷：基類的引用也可以指向派生類的對象，並且它的表現和指針是類似的。
修改上例中 main() 函數內部的代碼，用引用取代指針：
int main(){
D d(4, 40, 400, 4000);
A &ra = d;
B &rb = d;
C &rc = d;
ra.display();
rb.display();
rc.display();
return 0;
}
運行結果：
Class A: m_a=4
Class B: m_a=4, m_b=40
Class C: m_c=400
ra、rb、rc 是基類的引用，它們都引用了派生類對象 d，並調用了 display() 函數，從運行結果可以發現，雖然使用了派生類對象的成員變量，但是卻沒有使用派生類的成員函數，這和指針的表現是一樣的。
引用和指針的表現之所以如此類似，是因為引用和指針並沒有本質上的區別，引用僅僅是對指針進行了簡單封裝，讀者可以猛擊《引用在本質上是什麼，它和指針到底有什麼區別》一文深入了解。
最後需要注意的是，向上轉型後通過基類的對象、指針、引用只能訪問從基類繼承過去的成員（包括成員變量和成員函數），不能訪問派生類新增的成員。
