C++ day26 代码重用（二） 多重继承（MI, multiple inheritance，主要研究多重公有继承）

雨点打透心脏的1/2处 2023-07-24 03:09 22阅读 0赞

文章目录

  • 多重继承
    • 多重继承带来的两个主要问题
      • 从两个不同基类继承同名方法
      • 从两个或者更多相关基类继承同一个类的多个实例
    • 示例 多重公有继承
    • 代码
      • 先不写SingingWaiter类
        • 出现的问题
        • 做的好的地方
        • 学到或加深印象的地方
      • 由SingingWaiter类的问题引出虚基类
  • 虚基类
    • 虚基类的构造函数在派生链条中不可以自动传递信息
    • 用虚基类写SingingWaiter类
  • MI的其他复杂问题
    • 混合使用虚基类和非虚基类会导致派生类对象中有几个基类组件
    • 虚基类略改变了C++解析二义性的方式

多重继承

前面说的都是单继承，即只有一个基类。多重继承是有两个甚至更多的基类。

公有单继承和公有多重继承（基类都用public修饰）都表示is-a关系。

私有继承和保护继承描述的都是has-a关系。

多重继承带来的两个主要问题

反正和单继承相比，多重继承肯定是更难的，很容易出现问题。因此有很多C++程序员希望删除多重继承特性，但也有一部分人觉得MI对于一些比较特殊的工程来说是特别有用的，必不可少的，所以MI被保留了，但是一定要谨慎地使用。。。

从两个不同基类继承同名方法

从两个或者更多相关基类继承同一个类的多个实例

示例 多重公有继承

worker是一个抽象基类，即有纯虚函数的基类。用它派生出singer类和waiter类，再从singer和waiter类中派生出SingingWaiter类
在这里插入图片描述

代码

先不写SingingWaiter类

  1. //Worker.h
  2. #ifndef WORKER_H_
  3. #define WORKER_H_
  4. #include <string>
  5. class Worker// an abstract base class，不可以创建抽象基类的对象
  6. { 
  7. private:
  8.     std::string fullname;//包含
  9.     long id;
  10. public:
  11.     Worker():fullname("no one"), id(0L){ }
  12.     explicit Worker(const std::string & st):fullname(st), id(0L){ }
  13.     explicit Worker(long ID):fullname("no one"), id(ID){ }
  14.     Worker(const std::string & st, long ID):fullname(st), id(ID){ }
  15.     //纯虚析构函数，基类的析构函数必须是虚的，抽象基类至少有一个纯虚函数，在派生类中抽象基类的纯虚函数自动成为虚函数
  16.     virtual ~Worker() = 0;
  17.     virtual void Set();
  18.     virtual void Show() const;
  19. };
  21. class Waiter:public Worker // 公有继承，继承了一个Worker组件
  22. { 
  23. private:
  24.     int panache;
  25. public:
  26.     //默认参数在构造函数中的好处：一个构造函数相当于两个
  27.     explicit Waiter(int pa = 0):Worker(), panache(pa){ }//Worker()是调用基类Worker的默认构造函数，不给参数
  28.     explicit Waiter(const std::string & st, int pa = 0):Worker(st), panache(pa){ }
  29.     explicit Waiter(long ID, int pa = 0):Worker(ID), panache(pa){ }
  30.     //有默认参数就不需要Waiter(const std::string & st, long ID):Worker(st, ID), panache(0){}了
  31.     Waiter(const std::string & st, long ID, int pa = 0):Worker(st, ID), panache(pa){ }
  32.     Waiter(const Worker & wk, int pa = 0):Worker(wk), panache(pa){ }//虽然抽象基类不可有对象，但是可以在形参这么写，会进行类型转换
  33.     ~Waiter(){ }//和不写一样，会自动调用Worker的析构函数
  34.     void Set();
  35.     void Show() const;
  36. };
  38. class Singer:public Worker//继承了一个Worker组件
  39. { 
  40. protected://把一些整型常量定义为保护数据成员，即对于派生链条上的类而言相当于公有数据成员，对于外界相当于私有成员
  41.     enum { other, alto, contralto, soprano, bass, baritone, tenor};
  42.     enum { Vtypes = 7};
  43. private:
  44.     //静态私有成员是类的所有对象共享的，不属于任何一个对象
  45.     static const char *pv[Vtypes];//char指针数组,每个char指针指向一个字符串，表示一个声音类型
  46.     int voice;
  47. public:
  48.     Singer(int vo = 0):Worker(), voice(vo){ }
  49.     Singer(const std::string & st, long ID, int vo = other):Worker(st, ID), voice(vo){ }//vo的默认值写0或other都可以，最好写other
  50.     Singer(const Worker & wk, int vo = 0):Worker(wk), voice(vo){ }
  51.     void Set();
  52.     void Show() const;
  53. };
  54. #endif
  56. //Worker.cpp
  57. #include <string>
  58. #include <iostream>
  59. #include "Worker.h"
  60. using std::cin;
  61. using std::cout;
  62. using std::string;
  63. using std::endl;
  65. //Worker methods
  66. //虚析构函数必须实现，即使是纯虚析构
  67. Worker::~Worker(){ }
  69. void Worker::Set()//定义不写virtual关键字
  70. { 
  71.     cout << "Enter worker's full name:\n";
  72.     getline(cin, fullname);//iostream类的函数
  73.     cout << "Enter worker's ID:\n";
  74.     cin >> id;
  75.     //清空输入缓冲
  76.     while (cin.get() != '\n')
  77.         ;
  78. }
  80. void Worker::Show() const
  81. { 
  82.     cout << "Worker Name: " << fullname << endl;
  83.     cout << "Worker ID: " << id << endl;
  84. }
  86. //Waiter methods
  87. void Waiter::Set()
  88. { 
  89.     cout << "Worker Category: Waiter\n";
  90.     Worker::Set();
  91.     cout << "Enter waiter's panache rating:\n";
  92.     cin >> panache;
  93.     while (cin.get() != '\n')
  94.         ;
  95.     cout << endl;
  96. }
  98. void Waiter::Show() const
  99. { 
  100.     /* *错误代码：派生类不可以直接访问基类的私有成员，只可以用基类的公有方法去访问 *cout << "Waiter Name: " << fullname << endl; *cout << "Waiter ID: " << id << endl; */
  101.     cout << "Worker Category: Waiter\n";
  102.     Worker::Show();
  103.     cout << "Panache rating: " << panache << endl;
  104.     cout << endl;
  105. }
  107. //Singer methods
  108. //先给静态char指针数组赋值，虽然不是函数，但也可以写在实现文件中
  109.  const char * Singer::pv[] = { "other", "alto", "contralto", "soprano", "bass", "baritone", "tenor"};//一定要用类名限定！！！像方法一样
  111. void Singer::Set()
  112. { 
  113.     cout << "Worker Category: Singer\n";
  114.     Worker::Set();
  115.     cout << "Enter singer's voice type (integer 0 - 6):\n";
  116.     //展示给用户看所有可供选择的类型
  117.     int i;
  118.     for (i = 0; i < Vtypes; ++i)
  119.     { 
  120.         cout << i << ": " << pv[i] << " ";
  121.     }
  122.     cout << endl;
  123.     //保证输入正确
  124.     while (cin >> voice && (voice >= Vtypes || voice < 0))
  125.         cout << "Please enter a value >= 0 and < " << Vtypes << endl;
  126.     //清空输入队列
  127.     while (cin.get() != '\n')
  128.         ;
  129.     cout << endl;
  130. }
  132. void Singer::Show() const
  133. { 
  134.     cout << "Worker Category: Singer\n";
  135.     Worker::Show();
  136.     cout << "Singer's voice type: " << pv[voice] << endl;
  137.     cout << endl;
  138. }
  140. #include <iostream>
  141. #include "Worker.h"
  142. const int LIM = 4;
  143. using std::cout;
  145. //使用一个多态指针数组调用同名方法
  146. int main()
  147. { 
  148.     Waiter bob("Bob Apple", 123L, 4);
  149.     Singer mary("Mary Smith", 156L, 2);
  150.     Waiter anna;
  151.     Singer amy;
  153.     Worker *pw[LIM] = { &bob, &mary, &anna, &amy};//抽象基类的指针数组,bob和mary只是把他们的Worker组件（基类对象）的地址赋给了指针
  154.     int i;
  155.     for (i = 2; i < LIM; ++i)
  156.         pw[i]->Set();
  157.     for (i = 0; i < LIM; ++i)
  158.         pw[i]->Show();
  160.     return 0;
  161. }

输出

  1. Worker Category: Waiter
  2. Enter worker's full name: Anna Drop Enter worker's ID:
  3. 456
  4. Enter waiter's panache rating: 4 Worker Category: Singer Enter worker's full name:
  5. Sia Taylor
  6. Enter worker's ID: 1268 Enter singer's voice type (integer 0 - 6):
  7. 0: other  1: alto  2: contralto  3: soprano  4: bass  5: baritone  6: tenor
  8. 3
  10. Worker Category: Waiter
  11. Worker Name: Bob Apple
  12. Worker ID: 123
  13. Panache rating: 4
  15. Worker Category: Singer
  16. Worker Name: Mary Smith
  17. Worker ID: 156
  18. Singer's voice type: contralto Worker Category: Waiter Worker Name: Anna Drop Worker ID: 456 Panache rating: 4 Worker Category: Singer Worker Name: Sia Taylor Worker ID: 1268 Singer's voice type: soprano

出现的问题

  • 在派生类中企图使用基类的私有变量。。。必须要用基类公有方法才可以访问到，除非是保护成员变量
  • Singer(const std::string & st, long ID, int vo = other):Worker(st, ID), voice(vo){}中的, voice(vo)忘记写，导致了Singer mary(“Mary Smith”, 156L, 2);没有成功构造出想要的对象，但是这种情况不会在编译时发现，只会在运行时出错，刚开始还不知道为啥，调试发现voice的值打印不出来才想到这边出问题了。
  • 忘记写const char * Singer::pv[] = {“other”, “alto”, “contralto”, “soprano”, “bass”, “baritone”, “tenor”};中的类名限定符，在方法定义文件中定义静态变量，必须和方法一样，用类名限定起来，不然编译器不知道pv到底是哪个类的，尽管头文件包含此信息，但是编译器就是要你写清楚。

做的好的地方

  • const char * Singer::pv[] = {“other”, “alto”, “contralto”, “soprano”, “bass”, “baritone”, “tenor”};中书上代码没有const,于是报7个警告（一个词语一个），说C++禁止把string constant转换为char *类型，我就明白了，这属于const赋给非const的情况，当然会报错，于是这么改了就好了（头文件中也要加const：static const char *pv[Vtypes];）。
    在这里插入图片描述

学到或加深印象的地方

  • 基类指针数组实现多态，其中基类甚至可以是抽象基类。
  • 用enum枚举定义整型常量
  • 指针数组
  • 静态数据成员可以在方法文件中赋值
  • 基类的析构函数必须是虚函数，且虚析构函数必须要实现，即使是纯虚析构函数！
  • 检查输入是否正确（voice的输入必须是0-6）

由SingingWaiter类的问题引出虚基类

SingingWaiter类的问题：将继承两个Worker对象，使多态调用方法时因二义性而不可行

这里并不是真的说有Worker对象，因为毕竟抽象基类是不可以创建对象的，这么说仅仅是为了便于表达，不过还是说组件吧更严谨。

  1. class SingingWorker:public Singer, public Waiter//必须每个基类都用public修饰，因为默认的是private
  2. { ...};

由于 Waiter类和Singer类都继承了一个Worker组件，所以SingingWaiter有两个Worker组件，但是其实只需要一个Worker组件就好了，因为Singer类和Waiter类的Worker组件都一样又没区别。另外，这会在多态调用时造成二义性，使得程序出错：

  1. SingingWaiter ed;
  2. Worker *pw = &ed;//ed包含两个Worker组件，即有两个地址，于是编译器不知道要让pw指向谁

在这里插入图片描述

解决这种二义性要依靠类型转换：

  1. Worker * pw1 = (Waiter *) &ed;//指向Waiter中的Worker组件
  2. Worker * pw2 = (Singer *) &ed;

所以这种多重继承使得利用基类指针引用不同类的对象的多态性变复杂了。要多加一个类型转换才行。

但是光做个类型转换确实解决了这里的二义性问题，但只是解决了皮毛，并不釜底抽薪之举，因为如前所述，根本不需要两个Worker组件啊，再多的Worker组件都是一毛一样的，我们只需要一个！SingingWaiter类的对象应该只拥有一个Worker组件，即只有一个名字和一个ID。

这该怎么办呢？

于是C++迫不得已，专门为多重继承引入一个新技术——虚基类（virtual base class）。

虚基类

虚基类专门针对上面说的这种情况：让两个继承同一个基类（第一代类）的类（第二代类）共同派生的类（第三代类）的对象只有一个基类（第一代类）对象。

  1. class Singer:virtual public Worker{ ...}; 
  2. class Waiter:public virtual Worker{ ...};
  3. class SingingWaiter: public Singer, public Waiter{ ...};//则SingingWaiter对象只包含一个Worker组件的一个副本，即Singer类和Waiter类实际上共享了同一个Worker组件，而不是各自都引入一个Worker对象副本

public 和 virtual的顺序无所谓

在这里插入图片描述

需要注意的几点：

  • 虚基类中的”虚”和虚函数的“虚”不是一回事，没有关系。由于C++用户墙裂反对再引入新的关键字（已经够多了），所以就用了virtual。这实际上是一种关键字重载。
  • 有时候可能真的需要基类对象的多个副本，于是就不需要使用虚基类。这种情况虽然少，也是有的。

虚基类的构造函数在派生链条中不可以自动传递信息

以前的非虚基类：

  1. class A
  2. { 
  3. private:
  4.     int a;
  5. public:
  6.     A(int m = 0):a(m){ }
  7. };
  9. class B: public A
  10. { 
  11. private:
  12.     int b;
  13. public:
  14.     B(int m = 0, int n = 0):A(m), b(n){ }
  15. };
  17. class C:public B
  18. { 
  19. private:
  20.     int c;
  21. public:
  22.     C(int m = 0, n = 0, q = 0):B(m, n), c(q){ }
  23. };

可以看到，非虚基类中, B继承了A, C继承了B，在这个继承链条中，C只可以调用B的构造函数，不可以调用A的构造函数，因为B会自动调用A的构造函数。其中C把信息传给了B，B又把信息传给了A，相当于B是中间类，C通过中间了自动地把信息传给了基类A。

但是在虚基类中，这种在派生链条中通过中间类自动传递信息将不再行得通：

  1. SingingWaiter(const Worker & wk, int pa = 0, int vo = Singer::other):Waiter(wk, pa), Singer(wk, vo){ };

这句代码中，如果可以通过中间类自动传递信息，则Waiter和Singer的构造函数都会自动调用Worker类的构造函数，所以有2条不同路径都会把wk传给Worker基类，会造成冲突。

所以C++就规定：当基类是虚的时，禁止信息通过中间类自动传递给基类。所以上面的代码只会初始化panache和voice两个参数，那基类对象的那个组件怎么办呢？答案是：编译器调用Worker的默认构造函数去创建。
那如果不想用默认构造函数呢？则：

  1. SingingWaiter(const Worker & wk, int pa = 0, int vo = Singer::other):Worker(wk), Waiter(wk, pa), Singer(wk, vo){ };

注意这里相当于在第三代类的构造函数中使用了第一代类的构造函数，这在非虚基类是绝对不可以的！（非虚基类只允许在构造函数中调用派生链条中相邻的基类的构造函数）。

用虚基类写SingingWaiter类

前面三个类的代码也做了一些改动

  1. //Worker.h
  2. #ifndef WORKER_H_
  3. #define WORKER_H_
  4. #include <string>
  5. class Worker// an abstract base class，不可以创建抽象基类的对象
  6. { 
  7. private:
  8.     std::string fullname;//包含
  9.     long id;
  10. protected:
  11.     virtual void Data() const;
  12.     virtual void Get();
  13. public:
  14.     Worker():fullname("no one"), id(0L){ }
  15.     explicit Worker(const std::string & st):fullname(st), id(0L){ }
  16.     explicit Worker(long ID):fullname("no one"), id(ID){ }
  17.     Worker(const std::string & st, long ID):fullname(st), id(ID){ }
  18.     //纯虚析构函数，基类的析构函数必须是虚的，抽象基类至少有一个纯虚函数，在派生类中抽象基类的纯虚函数自动成为虚函数
  19.     virtual ~Worker() = 0;
  20.     virtual void Set() = 0;
  21.     virtual void Show() const = 0;
  22. };
  24. class Waiter:virtual public Worker // 公有继承
  25. { 
  26. private:
  27.     int panache;
  28. protected:
  29.     void Data() const;
  30.     void Get();
  31. public:
  32.     //默认参数在构造函数中的好处：一个构造函数相当于两个
  33.     explicit Waiter(int pa = 0):Worker(), panache(pa){ }//Worker()是调用基类Worker的默认构造函数，不给参数
  34.     explicit Waiter(const std::string & st, int pa = 0):Worker(st), panache(pa){ }
  35.     explicit Waiter(long ID, int pa = 0):Worker(ID), panache(pa){ }
  36.     //有默认参数就不需要Waiter(const std::string & st, long ID):Worker(st, ID), panache(0){}了
  37.     Waiter(const std::string & st, long ID, int pa = 0):Worker(st, ID), panache(pa){ }
  38.     Waiter(const Worker & wk, int pa = 0):Worker(wk), panache(pa){ }//虽然抽象基类不可有对象，但是可以在形参这么写，会进行类型转换
  39.     ~Waiter(){ }//和不写一样，会自动调用Worker的析构函数
  40.     void Set();
  41.     void Show() const;
  42. };
  44. class Singer: virtual public Worker
  45. { 
  46. protected://把一些整型常量定义为保护数据成员，即对于派生链条上的类而言相当于公有数据成员，对于外界相当于私有成员
  47.     enum { other, alto, contralto, soprano, bass, baritone, tenor};
  48.     enum { Vtypes = 7};
  49.     void Data() const;
  50.     void Get();
  51. private:
  52.     //静态私有成员是类的所有对象共享的，不属于任何一个对象
  53.     static const char *pv[Vtypes];//char指针数组,每个char指针指向一个字符串，表示一个声音类型
  54.     int voice;
  55. public:
  56.     Singer(int vo = 0):Worker(), voice(vo){ }
  57.     Singer(const std::string & st, long ID, int vo = other):Worker(st, ID), voice(vo){ }//vo的默认值写0或other都可以，最好写other
  58.     Singer(const Worker & wk, int vo = 0):Worker(wk), voice(vo){ }
  59.     void Set();
  60.     void Show() const;
  61. };
  63. class SingingWaiter: public Singer, public Waiter
  64. { 
  65. protected:
  66.     void Data() const;
  67.     void Get();
  68. public:
  69.     SingingWaiter(){ }
  70.     SingingWaiter(const std::string & st, long ID, int vo = Singer::other, int pa = 0)
  71.         : Worker(st, ID), Singer(st, ID, vo), Waiter(st, ID, pa){ }
  72.     SingingWaiter(const Worker & wk, int vo = Singer::other, int pa = 0)
  73.         : Worker(wk), Singer(wk, vo), Waiter(wk, pa){ }
  74.     SingingWaiter(const Waiter & wa, int vo = other):Singer(vo), Waiter(wa){ }//必须先写Singer,否则警告（这个顺序必须按照声明类时的public Waiter, public Singer来）
  75.     SingingWaiter(const Singer & si, int pa = 0):Singer(si), Waiter(pa){ }
  76.     void Show() const;
  77.     void Set();
  78. };
  79. #endif
  81. //Worker.cpp
  82. #include <string>
  83. #include <iostream>
  84. #include "Worker.h"
  85. using std::cin;
  86. using std::cout;
  87. using std::string;
  88. using std::endl;
  90. //Worker methods
  91. //虚析构函数必须实现，即使是纯虚析构
  92. Worker::~Worker(){ }
  93. void Worker::Data() const
  94. { 
  95.     cout << "Worker Name: " << fullname << endl;
  96.     cout << "Worker ID: " << id << endl;
  97. }
  99. void Worker::Get()
  100. { 
  101.     cout << "Enter worker's full name:\n";
  102.     getline(cin, fullname);//iostream类的函数
  103.     cout << "Enter worker's ID:\n";
  104.     cin >> id;
  105.     //清空输入缓冲
  106.     while (cin.get() != '\n')
  107.         ;
  108. }
  110. //Waiter methods
  111. void Waiter::Data() const
  112. { 
  113.     cout << "panache rating: " << panache << endl;
  114. }
  116. void Waiter::Get()
  117. { 
  118.     cout << "Enter waiter's panache rating:\n";
  119.     cin >> panache;
  120.     while (cin.get() != '\n')
  121.         ;
  122. }
  124. void Waiter::Set()
  125. { 
  126.     cout << "Worker Category: Waiter\n";
  127.     Worker::Get();
  128.     Get();
  129.     cout << endl;
  130. }
  132. void Waiter::Show() const
  133. { 
  134.     cout << "Worker Category: Waiter\n";
  135.     Worker::Data();
  136.     Data();
  137.     cout << endl;
  138. }
  140. //Singer methods
  141. //先给静态char指针数组赋值，虽然不是函数，但也可以写在实现文件中
  142. const char * Singer::pv[] = { "other", "alto", "contralto", "soprano", "bass", "baritone", "tenor"};//一定要用类名限定！！！像方法一样
  144. void Singer::Data() const
  145. { 
  146.     cout << "Singer's voice type: " << pv[voice] << endl;
  147. }
  149. void Singer::Get()
  150. { 
  151.     cout << "Enter singer's voice type (integer 0 - 6):\n";
  152.     //展示给用户看所有可供选择的类型
  153.     int i;
  154.     for (i = 0; i < Vtypes; ++i)
  155.     { 
  156.         cout << i << ": " << pv[i] << " ";
  157.     }
  158.     cout << endl;
  159.     //保证输入正确
  160.     while (cin >> voice && (voice >= Vtypes || voice < 0))
  161.         cout << "Please enter a value >= 0 and < " << Vtypes << endl;
  162.     //清空输入队列
  163.     while (cin.get() != '\n')
  164.         ;
  165. }
  167. void Singer::Set()
  168. { 
  169.     cout << "Worker Category: Singer\n";
  170.     Worker::Get();
  171.     Get();
  172.     cout << endl;
  173. }
  175. void Singer::Show() const
  176. { 
  177.     cout << "Worker Category: Singer\n";
  178.     Worker::Data();
  179.     Data();
  180.     cout << endl;
  181. }
  183. //SingingWaiter methods
  184. void SingingWaiter::Data() const
  185. { 
  186.     Singer::Data();
  187.     Waiter::Data();
  188. }
  190. void SingingWaiter::Get()
  191. { 
  192.     Singer::Get();
  193.     Waiter::Get();
  194. }
  196. void SingingWaiter::Set()
  197. { 
  198.     cout << "Worker Category: Singing Waiter\n";
  199.     Worker::Get();
  200.     Get();
  201. }
  203. void SingingWaiter::Show() const
  204. { 
  205.     cout << "Worker Category: Singing Waiter\n";
  206.     Worker::Data();
  207.     Data();
  208. }
  210. #include <iostream>
  211. #include <cstring>
  212. #include "Worker.h"
  213. const int SIZE = 5;
  214. using std::cout;
  215. using std::cin;
  217. //使用一个多态指针数组调用同名方法
  218. int main()
  219. { 
  220.     SingingWaiter amy("Amy Smith", 152L, 2, 3);
  221.     amy.Waiter::Show();//不用类名限定会导致二义性，因为SingingWaiter的两个基类Singer类和Waiter类都有Show()方法，自己又没定义Show()方法
  222.     amy.Singer::Show();
  224.     Worker *pw[SIZE];
  225.     int ct;
  226.     for (ct = 0;ct < SIZE; ++ct)
  227.     { 
  228.         char choice;
  229.         cout << "Enter the employee category:\n";
  230.         cout << "w: waiter s: singer\n"
  231.              << "t: singing waiter q: quit\n";
  233.         while (cin >> choice && (std::strchr("wstq", choice) == NULL))
  234.         { 
  235.             cout << "Please enter w, s, t, or q: ";
  236.         }
  237.         if (choice == 'q')
  238.             break;
  239.         switch(choice)
  240.         { 
  241.             case 'w':
  242.                 pw[ct] = new Waiter; break;
  243.             case 's':
  244.                 pw[ct] = new Singer; break;
  245.             case 't':
  246.                 pw[ct] = new SingingWaiter; break;
  247.         }
  248.         cin.get();//这句必不可少！！！cin >> choice把输入队列的字母给了choice，但是仍然还在输入队列中，要用cin.get()才可以读掉，否则后面没法输入名字
  249.         pw[ct]->Set();
  251.     }
  253.     cout << "Here is your staff:\n";
  254.     int i;
  255.     for (i = 0; i < ct; ++i)
  256.         { 
  257.             pw[i]->Show();
  258.             cout << '\n';
  259.         }
  260.     for (i = 0; i < ct; ++i)
  261.         delete pw[i];
  263.     return 0;
  264. }

输出

  1. Worker Category: Waiter
  2. Worker Name: Amy Smith
  3. Worker ID: 152
  4. Singer's voice type: contralto panache rating: 3 Worker Category: Singer Worker Name: Amy Smith Worker ID: 152 Singer's voice type: contralto
  5. panache rating: 3
  7. Enter the employee category:
  8. w: waiter  s: singer
  9. t: singing waiter q: quit
  10. w
  11. Worker Category: Waiter
  12. Enter worker's full name: Anna Smith Enter worker's ID:
  13. 343
  14. Enter waiter's panache rating: 2 Enter the employee category: w: waiter s: singer t: singing waiter q: quit s Worker Category: Singer Enter worker's full name:
  15. Joy Sue
  16. Enter worker's ID: 4245 Enter singer's voice type (integer 0 - 6):
  17. 0: other  1: alto  2: contralto  3: soprano  4: bass  5: baritone  6: tenor
  18. 5
  20. Enter the employee category:
  21. w: waiter  s: singer
  22. t: singing waiter q: quit
  23. t
  24. Worker Category: Singing Waiter
  25. Enter worker's full name: Mary Hellon Enter worker's ID:
  26. 125
  27. Enter singer's voice type (integer 0 - 6): 0: other 1: alto 2: contralto 3: soprano 4: bass 5: baritone 6: tenor 4 Enter waiter's panache rating:
  28. 6
  29. Enter the employee category:
  30. w: waiter  s: singer
  31. t: singing waiter q: quit
  32. q
  33. Here is your staff:
  34. Worker Category: Waiter
  35. Worker Name: Anna Smith
  36. Worker ID: 343
  37. panache rating: 2
  40. Worker Category: Singer
  41. Worker Name: Joy Sue
  42. Worker ID: 4245
  43. Singer's voice type: baritone Worker Category: Singing Waiter Worker Name: Mary Hellon Worker ID: 125 Singer's voice type: bass
  44. panache rating: 6

MI的其他复杂问题

混合使用虚基类和非虚基类会导致派生类对象中有几个基类组件

比如类A被作为虚基类派生出类B和C，又被作为非虚基类派生出类D和E，然后类B,C,D,E共同派生了类F。那么F类的对象中有几个A类的组件（对象）呢？

答案是3个。因为B和C由于把A当做虚基类继承，所以F中从BC这里只会得到一个A的对象组件，BC共享这一个组件；而DE是非虚基类继承，则每人都有一个A类对象组件，于是在F类中一共就有三个A类的对象组件。

反正看有几条路径。每个非虚基类都提供一条路径，所有虚基类一起提供一条路径。

一般情况下，这种基类的多个对象组件副本都是棘手的问题，而不是所希望的；只有极少数的特殊编程问题中才需要多个基类对象副本，以后遇到再说。

虚基类略改变了C++解析二义性的方式

怎么改变的呢？之前是只有类名限定，现在是先用优先顺序，优先顺序无法消除二义性才上类名限定。

如果是只用非虚基类，那么如果类从不同的类中继承了两个或更多的同名方法或同名数据，那么只需要使用类名限定就可以消除调用这个方法的二义性了。

如果在非虚基类中，其实问题可以更简单一丁点：即有时候不需要类名限定也没有二义性的问题，这是因为虚基类会使得同名方法之间有个优先顺序！只要优先顺序可以消除二义性就不需要类名限定了；有时候（优先顺序一样，消除不了二义性）则还是和非虚基类一样，需要类名限定以消除二义性。

注意只有虚基类才有同名方法之间的优先顺序哦，非虚基类没有这个说法。并且虽然用优先顺序可以消除二义性的时候不需要类名限定，但是这需要自己很清楚优先顺序的判断，别搞错了。

什么优先顺序？一个成员名如何优先于另一个成员名？
答案：派生类的名称优先于直接或间接祖先类（隔代亲，隔一代或多代）中的相同名称。

举个栗子：

  1. class B
  2. { 
  3. public:
  4.     short q();
  5. };
  7. class C: virtual public B//把B当做虚基类继承，只要这里使用virtual,则基类B成为虚基类
  8. { 
  9. public:
  10.     long q();
  11.     int omg();
  12. };
  14. class D: public C
  15. { };
  17. class E: virtual public B
  18. { 
  19. private:
  20.     int omg();
  21. };
  23. class F: public D, public E
  24. { };

草画了一个继承图
在这里插入图片描述
F类的q()方法: F类从D，E两条路径都集继承到了名为q的方法，我们要分析优先性。先看D路径，D类没有新方法，其q()方法来自于公有继承C类的公有q()方法；再看E路径，E的q()来自于虚公有继承B类的公有q()方法。看继承图发现，C类的q()优先于B类的q()，所以F类中调用q()方法没有二义性，相当于C::q()。但是如果你真的想用B类的，则用B::q()即可。

F类的omg()方法：F类从D，E两条路径都集继承到了名为omg的方法，我们要分析优先性。先看D路径，D类没有新方法，其omg()方法来自于公有继承C类的公有omg()方法；再看E路径，E的omg()是自己的私有方法。看继承图发现，C类和E类不是派生和被派生的关系，所以他们的同名方法没有优先顺序一说，所以F类中调用omg()方法有二义性，虽然不可以在F类中使用E的私有方法，但使用omg()还是要必须明确指出C::omg()。

总之，使用虚基类会增加一点复杂性，多判断一个优先顺序，主要是多重继承中的最终派生类会通过多条途径继承同一个基类引起的。总之，使用MI要慎之又慎，一定要注意类名限定和虚基类的优先规则。

发表评论

表情：
评论列表 （有 0 条评论，22人围观）

还没有评论，来说两句吧...

相关阅读