派生類都只有一個基類，稱為單繼承（Single Inheritance）。除此之外，C++也支援多繼承（Multiple Inheritance），即一個派生類可以有兩個或多個基類。

多繼承容易讓程式碼邏輯複雜、思路混亂，一直備受爭議，中小型專案中較少使用，後來的 Java、C#、PHP 等乾脆取消了多繼承。

多繼承的語法也很簡單，將多個基類用逗號隔開即可。例如已聲明瞭類A、類B和類C，那麼可以這樣來宣告派生類D：

class D: public A, private B, protected C{
    //類D新增加的成員
}

D 是多繼承形式的派生類，它以公有的方式繼承 A 類，以私有的方式繼承 B 類，以保護的方式繼承 C 類。D 根據不同的繼承方式獲取 A、B、C 中的成員，確定它們在派生類中的訪問許可權。

多繼承下的建構函式

多繼承形式下的建構函式和單繼承形式基本相同，只是要在派生類的建構函式中呼叫多個基類的建構函式。以上面的 A、B、C、D 類為例，D 類建構函式的寫法為：

D(形參列表): A(實參列表), B(實參列表), C(實參列表){
    //其他操作
}

基類建構函式的呼叫順序和和它們在派生類建構函式中出現的順序無關，而是和宣告派生類時基類出現的順序相同。仍然以上面的 A、B、C、D 類為例，即使將 D 類建構函式寫作下面的形式：

D(形參列表): B(實參列表), C(實參列表), A(實參列表){
    //其他操作
}

那麼也是先呼叫 A 類的建構函式，再呼叫 B 類建構函式，最後呼叫 C 類建構函式。

下面是一個多繼承的例項：

1. #include <iostream>
2. using namespace std;
4. //基類
5. class BaseA{
6. public:
7. BaseA(int a, int b);
8. ~BaseA();
9. protected:
10. int m_a;
11. int m_b;
12. };
13. BaseA::BaseA(int a, int b): m_a(a), m_b(b){
14. cout<<"BaseA constructor"<<endl;
15. }
16. BaseA::~BaseA(){
17. cout<<"BaseA destructor"<<endl;
18. }
20. //基類
21. class BaseB{
22. public:
23. BaseB(int c, int d);
24. ~BaseB();
25. protected:
26. int m_c;
27. int m_d;
28. };
29. BaseB::BaseB(int c, int d): m_c(c), m_d(d){
30. cout<<"BaseB constructor"<<endl;
31. }
32. BaseB::~BaseB(){
33. cout<<"BaseB destructor"<<endl;
34. }
36. //派生類
37. class Derived: public BaseA, public BaseB{
38. public:
39. Derived(int a, int b, int c, int d, int e);
40. ~Derived();
41. public:
42. void show();
43. private:
44. int m_e;
45. };
46. Derived::Derived(int a, int b, int c, int d, int e): BaseA(a, b), BaseB(c, d), m_e(e){
47. cout<<"Derived constructor"<<endl;
48. }
49. Derived::~Derived(){
50. cout<<"Derived destructor"<<endl;
51. }
52. void Derived::show(){
53. cout<<m_a<<", "<<m_b<<", "<<m_c<<", "<<m_d<<", "<<m_e<<endl;
54. }
56. int main(){
57. Derived obj(1, 2, 3, 4, 5);
58. obj.show();
59. return 0;
60. }

執行結果：
BaseA constructor
BaseB constructor
Derived constructor
1, 2, 3, 4, 5
Derived destructor
BaseB destructor
BaseA destructor

從執行結果中還可以發現，多繼承形式下解構函式的執行順序和建構函式的執行順序相反。

命名衝突

當兩個或多個基類中有同名的成員時，如果直接訪問該成員，就會產生命名衝突，編譯器不知道使用哪個基類的成員。這個時候需要在成員名字前面加上類名和域解析符::，以顯式地指明到底使用哪個類的成員，消除二義性。

修改上面的程式碼，為 BaseA 和 BaseB 類新增 show() 函式，並將 Derived 類的 show() 函式更名為 display()：

1. #include <iostream>
2. using namespace std;
4. //基類
5. class BaseA{
6. public:
7. BaseA(int a, int b);
8. ~BaseA();
9. public:
10. void show();
11. protected:
12. int m_a;
13. int m_b;
14. };
15. BaseA::BaseA(int a, int b): m_a(a), m_b(b){
16. cout<<"BaseA constructor"<<endl;
17. }
18. BaseA::~BaseA(){
19. cout<<"BaseA destructor"<<endl;
20. }
21. void BaseA::show(){
22. cout<<"m_a = "<<m_a<<endl;
23. cout<<"m_b = "<<m_b<<endl;
24. }
26. //基類
27. class BaseB{
28. public:
29. BaseB(int c, int d);
30. ~BaseB();
31. void show();
32. protected:
33. int m_c;
34. int m_d;
35. };
36. BaseB::BaseB(int c, int d): m_c(c), m_d(d){
37. cout<<"BaseB constructor"<<endl;
38. }
39. BaseB::~BaseB(){
40. cout<<"BaseB destructor"<<endl;
41. }
42. void BaseB::show(){
43. cout<<"m_c = "<<m_c<<endl;
44. cout<<"m_d = "<<m_d<<endl;
45. }
47. //派生類
48. class Derived: public BaseA, public BaseB{
49. public:
50. Derived(int a, int b, int c, int d, int e);
51. ~Derived();
52. public:
53. void display();
54. private:
55. int m_e;
56. };
57. Derived::Derived(int a, int b, int c, int d, int e): BaseA(a, b), BaseB(c, d), m_e(e){
58. cout<<"Derived constructor"<<endl;
59. }
60. Derived::~Derived(){
61. cout<<"Derived destructor"<<endl;
62. }
63. void Derived::display(){
64. BaseA::show(); //呼叫BaseA類的show()函式
65. BaseB::show(); //呼叫BaseB類的show()函式
66. cout<<"m_e = "<<m_e<<endl;
67. }
69. int main(){
70. Derived obj(1, 2, 3, 4, 5);
71. obj.display();
72. return 0;
73. }

請讀者注意第 64、65 行程式碼，我們顯式的指明瞭要呼叫哪個基類的 show() 函式。