C++多继承（多重继承）

标签：多重 BaseB cout BaseA 继承 Derived C++ int public

派生类都只有一个基类，称为单继承（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() 函数。

标签：多重,BaseB,cout,BaseA,继承,Derived,C++,int,public
From： https://www.cnblogs.com/threebody1379/p/16934611.html