原文來源：https://www.jb51.net/article/72586.htm#

C++基類與派生類的轉換
在公用繼承、私有繼承和保護繼承中，只有公用繼承能較好地保留基類的特徵，它保留了除建構函式和解構函式以外的基類所有成員，基類的公用或保護成員的訪問許可權在派生類中全部都按原樣保留下來了，在派生類外可以呼叫基類的公用成員函式訪問基類的私有成員。因此，公用派生類具有基類的全部功能，所有基類能夠實現的功能， 公用派生類都能實現。而非公用派生類（私有或保護派生類）不能實現基類的全部功能（例如在派生類外不能呼叫基類的公用成員函式訪問基類的私有成員）。因此，只有公用派生類才是基類真正的子型別，它完整地繼承了基類的功能。

不同型別資料之間在一定條件下可以進行型別的轉換，例如整型資料可以賦給雙精度型變數，在賦值之前，把整型資料先轉換成為雙精度型資料，但是不能把一個整型資料賦給指標變數。這種不同型別資料之間的自動轉換和賦值，稱為賦值相容。現在要討論 的問題是：基類與派生類物件之間是否也有賦值相容的關係，可否進行型別間的轉換？

回答是可以的。基類與派生類物件之間有賦值相容關係，由於派生類中包含從基類繼承的成員，因此可以將派生類的值賦給基類物件，在用到基類物件的時候可以用其子類物件代替。具體表現在以下幾個方面。

1) 派生類物件可以向基類物件賦值

可以用子類(即公用派生類)物件對其基類物件賦值。如

A a1; //定義基類A物件a1
B b1; //定義類A的公用派生類B的物件b1
a1=b1;//用派生類B物件b1對基類物件a1賦值

在賦值時捨棄派生類自己的成員。也就是“大材小用”，如圖

實際上，所謂賦值只是對資料成員賦值，對成員函式不存在賦值問題。

請注意，賦值後不能企圖通過物件a1去訪問派生類物件b1的成員，因為b1的成員與a1的成員是不同的。假設age是派生類B中增加的公用資料成員，分析下面的用法：
    a1.age=23;  //錯誤，a1中不包含派生類中增加的成員
    b1.age=21;  //正確，b1中包含派生類中增加的成員

應當注意，子型別關係是單向的、不可逆的。B是A的子型別，不能說A是B的子型別。只能用子類物件對其基類物件賦值，而不能用基類物件對其子類物件賦值，理由是顯然的，因為基類物件不包含派生類的成員，無法對派生類的成員賦值。同理，同一基類的不同派生類物件之間也不能賦值。

2) 派生類物件可以替代基類物件向基類物件的引用進行賦值或初始化

如已定義了基類A物件a1，可以定義a1的引用變數：

  A a1; //定義基類A物件a1
  B b1; //定義公用派生類B物件b1
  A& r=a1; //定義基類A物件的引用變數r，並用a1對其初始化

這時，引用變數r是a1的別名，r和a1共享同一段儲存單元。也可以用子類物件初始化引用變數r，將上面最後一行改為

A& r=b1; //定義基類A物件的引用變數r，並用派生類B物件b1對其初始化

或者保留上面第3行“A& r=a1;”，而對r重新賦值：

  r=b1; //用派生類B物件b1對a1的引用變數r賦值

注意，此時r並不是b1的別名，也不與b1共享同一段儲存單元。它只是b1中基類部分的別名，r與b1中基類部分共享同一段儲存單元，r與b1具有相同的起始地址。

3) 如果函式的引數是基類物件或基類物件的引用，相應的實參可以用子類物件。

如有一函式：

fun: void fun(A& r) //形參是類A的物件的引用變數
  {
    cout<<r.num<<endl;
  } //輸出該引用變數的資料成員num

函式的形參是類A的物件的引用變數，本來實參應該為A類的物件。由於子類物件與派生類物件賦值相容，派生類物件能自動轉換型別，在呼叫fun函式時可以用派生類B的物件b1作實參：

 fun(b1);

輸出類B的物件b1的基類資料成員num的值。

與前相同，在fun函式中只能輸出派生類中基類成員的值。

4) 派生類物件的地址可以賦給指向基類物件的指標變數，也就是說，指向基類物件的指標變數也可以指向派生類物件。

[例] 定義一個基類Student(學生)，再定義Student類的公用派生類Graduate(研究生)， 用指向基類物件的指標輸出資料。本例主要是說明用指向基類物件的指標指向派生類物件，為了減少程式長度，在每個類中只設很少成員。學生類只設num(學號),name(名字)和score(成績)3個數據成員，Graduate類只增加一個數據成員pay(工資)。程式如下：

#include <iostream>
#include <string>
using namespace std;
class Student//宣告Student類
{
public:
  Student(int, string,float); //宣告建構函式
  void display( ); //宣告輸出函式
private:
  int num;
  string name;
  float score;
};
Student::Student(int n, string nam,float s) //定義建構函式
{
  num=n;
  name=nam;
  score=s;
}
void Student::display( ) //定義輸出函式
{
  cout<<endl<<"num:"<<num<<endl;
  cout<<"name:"<<name<<endl;
  cout<<"score:"<<score<<endl;
}
class Graduate:public Student //宣告公用派生類Graduate
{
public:
 Graduate(int, string ,float,float); //宣告建構函式
 void display( ); //宣告輸出函式
private:
 float pay; //工資
};
//定義建構函式
Graduate::Graduate(int n, string nam,float s,float p):Student(n,nam,s),pay(p){ }
void Graduate::display() //定義輸出函式
{
  Student::display(); //呼叫Student類的display函式
  cout<<"pay="<<pay<<endl;
}
int main()
{
  Student stud1(1001,"Li",87.5); //定義Student類物件stud1
  Graduate grad1(2001,"Wang",98.5,563.5); //定義Graduate類物件grad1
  Student *pt=&stud1; //定義指向Student類物件的指標並指向stud1
  pt->display( ); //呼叫stud1.display函式
  pt=&grad1; //指標指向grad1
  pt->display( ); //呼叫grad1.display函式
}

下面對程式的分析很重要，請大家仔細閱讀和思考。

很多讀者會認為，在派生類中有兩個同名的display成員函式，根據同名覆蓋的規則，被呼叫的應當是派生類Graduate物件的display函式，在執行Graduate::display函式過程中呼叫Student::display函式，輸出num,name,score，然後再輸出pay的值。

事實上這種推論是錯誤的，先看看程式的輸出結果：

num:1001
name:Li
score:87.5

num:2001
name:wang
score:98.5

前3行是學生stud1的資料，後3行是研究生grad1的資料，並沒有輸出pay的值。

問題在於pt是指向Student類物件的指標變數，即使讓它指向了grad1，但實際上pt指向的是grad1中從基類繼承的部分。

通過指向基類物件的指標，只能訪問派生類中的基類成員，而不能訪問派生類增加的成員。所以pt->display()呼叫的不是派生類Graduate物件所增加的display函式，而是基類的display函式，所以只輸出研究生grad1的num,name,score3個數據。

如果想通過指標輸出研究生grad1的pay，可以另設一個指向派生類物件的指標變數ptr，使它指向grad1，然後用ptr->display()呼叫派生類物件的display函式。但這不大方便。

通過本例可以看到，用指向基類物件的指標變數指向子類物件是合法的、安全的，不會出現編譯上的錯誤。但在應用上卻不能完全滿足人們的希望，人們有時希望通過使用基類指標能夠呼叫基類和子類物件的成員。如果能做到這點，程式人員會感到方便。後續章節將會解決這個問題。辦法是使用虛擬函式和多型性。

C++虛基類詳解
多繼承時很容易產生命名衝突，即使我們很小心地將所有類中的成員變數和成員函式都命名為不同的名字，命名衝突依然有可能發生，比如非常經典的菱形繼承層次。如下圖所示：

類A派生出類B和類C，類D繼承自類B和類C，這個時候類A中的成員變數和成員函式繼承到類D中變成了兩份，一份來自 A-->B-->D 這一路，另一份來自 A-->C-->D 這一條路。

在一個派生類中保留間接基類的多份同名成員，雖然可以在不同的成員變數中分別存放不同的資料，但大多數情況下這是多餘的：因為保留多份成員變數不僅佔用較多的儲存空間，還容易產生命名衝突，而且很少有這樣的需求。

為了解決這個問題，C++提供了虛基類，使得在派生類中只保留間接基類的一份成員。

宣告虛基類只需要在繼承方式前面加上 virtual 關鍵字，請看下面的例子：

#include <iostream>
using namespace std;
class A{
protected:
  int a;
public:
  A(int a):a(a){}
};
class B: virtual public A{ //宣告虛基類
protected:
  int b;
public:
  B(int a, int b):A(a),b(b){}
};
class C: virtual public A{ //宣告虛基類
protected:
  int c;
public:
  C(int a, int c):A(a),c(c){}
};
class D: virtual public B, virtual public C{ //宣告虛基類
private:
  int d;
public:
  D(int a, int b, int c, int d):A(a),B(a,b),C(a,c),d(d){}
  void display();
};
void D::display(){
  cout<<"a="<<a<<endl;
  cout<<"b="<<b<<endl;
  cout<<"c="<<c<<endl;
  cout<<"d="<<d<<endl;
}
int main(){
  (new D(1, 2, 3, 4)) -> display();
  return 0;
}

執行結果：

a=1
b=2
c=3
d=4

本例中我們使用了虛基類，在派生類D中只有一份成員變數 a 的拷貝，所以在 display() 函式中可以直接訪問 a，而不用加類名和域解析符。

請注意派生類D的建構函式，與以往的用法有所不同。以往，在派生類的建構函式中只需負責對其直接基類初始化，再由其直接基類負責對間接基類初始化。現在，由於虛基類在派生類中只有一份成員變數，所以對這份成員變數的初始化必須由派生類直接給出。如果不由最後的派生類直接對虛基類初始化，而由虛基類的直接派生類（如類B和類C）對虛基類初始化，就有可能由於在類B和類C的建構函式中對虛基類給出不同的初始化引數而產生矛盾。所以規定：在最後的派生類中不僅要負責對其直接基類進行初始化，還要負責對虛基類初始化。

有的讀者會提出：類D的建構函式通過初始化表調了虛基類的建構函式A，而類B和類C的建構函式也通過初始化表呼叫了虛基類的建構函式A，這樣虛基類的建構函式豈非被呼叫了3次？大家不必過慮，C++編譯系統只執行最後的派生類對虛基類的建構函式的呼叫，而忽略虛基類的其他派生類（如類B和類C）對虛基類的建構函式的呼叫，這就保證了虛基類的資料成員不會被多次初始化。

最後請注意：為了保證虛基類在派生類中只繼承一次，應當在該基類的所有直接派生類中宣告為虛基類，否則仍然會出現對基類的多次繼承。

可以看到：使用多重繼承時要十分小心，經常會出現二義性問題。上面的例子是簡單的，如果派生的層次再多一些，多重繼承更復雜一些，程式設計師就很容易陷人迷 魂陣，程式的編寫、除錯和維護工作都會變得更加困難。因此很多程式設計師不提倡在程式中使用多重繼承，只有在比較簡單和不易出現二義性的情況或實在必要時才使用多重繼承，能用單一繼承解決的問題就不要使用多重繼承。也正由於這個原因，C++之後的很多面向物件的程式語言（如Java、Smalltalk、C#、PHP等）並不支援多重繼承。