1.继承的三种方式：

公有继承(public),私有继承(private),保护继承(protected)

三种继承方式的说明，如下表所示：

特征	公有继承	保护继承	私有继承
公有成员变成	派生类的公有成员	派生类的保护成员	派生类的私有成员
保护成员变成	派生类的保护成员	派生类的保护成员	派生类的私有成员
私有成员变成	只能通过基类接口访问	只能通过基类接口访问	只能通过基类接口访问
能否隐式向上转换	是	是	否

 

 

 

 

                                                                                                                                                                                                                                                                      

2.什么是多继承

一个类有多个基类，那么这种继承关系就叫做多继承。

比如有两个类，服务员类Waiter，歌手类Singer，我们有一个类既是服务员，又是歌手，

那么我们可以定义类的多继承关系如下：

class Waiter{};class Singer{};class SingerWaiter:public Waiter,public Singer{};

3.使用多继承会带来哪些问题

多继承比单继承复杂，也更容易出现问题，因此我们不建议使用多继承。

多继承的两个主要问题是：

1)从两个不同的基类，继承同名方法

如下例所示：

class Waiter{public:    void work(){std::cout<<"Service"<

编译器不知道该调用哪个基类的work方法，所以会报singerWaiter.work();不明确错误。

2)从多个基类间接继承同一个类的多个实例

如下例所示：

class Worker{};class Waiter:public Worker{};class Singer:public Worker{};class SingerWaiter:public Waiter,public Singer{};int main(){    SingerWaiter singerWaiter;    Worker *pw = &singerWaiter;    return 0;}

会报错Worker *pw = &singerWaiter;基类Worker不明确。

这是因为SingerWaiter对象创建时，会分别调用Waiter类和Singer类的构造函数，

Waiter类和Singer类又会分别调用Worker类的构造函数，生成了两份Worker类的实例，

所以pw指针，不知道该指向哪一份Worker实例。

4.如何解决多继承带来的问题

对于问题一，我们在调用时，需要明确指出具体要调用哪个类的方法，如下所示：

int main(){    SingerWaiter singerWaiter;    singerWaiter.Waiter::work();//调用Waiter类的方法    singerWaiter.Singer::work();//调用Singer类的方法    return 0;}

对于问题二，我们引入了虚基类的概念。如下所示：

class Worker{};class Waiter:virtual public Worker{};class Singer:virtual public Worker{};class SingerWaiter:public Waiter,public Singer{};int main(){    SingerWaiter singerWaiter;    Worker *pw = &singerWaiter;    return 0;}

我们在子类继承时，声明一个virtual关键字，这时，就表明基类Worker是一个虚基类。

实例化SingerWaiter时产生的Waiter对象和Singer对象，共享一个基类Worker对象。

5.使用虚基类需要注意的问题

我们知道继承关系中，类的构造函数具有传递性，如以下代码所示：

class A{private:    int a;public:    A(int n=0):a(n){}    int get(){
   return a;}};class B:public A{private:    int b;public:    B(int m=0,int n=0):A(n),b(m){}    int get(){
   return b;}};class C:public B{private:    int c;public:    C(int q=0,int m=0,int n=0):B(m,n),c(q){}    int get(){
   return c;}    void Show()    {        std::cout<
     
      <<" "<
      
       <<" "<
       
        <
       
      
     

输出结果为： 3 2 1

调用C的构造函数，则B,A构造函数都将使用传入的参数进行初始化。

 

我们再看使用虚基类的情况：

class A{private:    int a;public:    A(int n=0):a(n){}    int get(){
   return a;}};class B:virtual public A{private:    int b;public:    B(int m=0,int n=0):A(n),b(m){}    int get(){
   return b;}};class C:public B{private:    int c;public:    C(int q=0,int m=0,int n=0):B(m,n),c(q){}    int get(){
   return c;}    void Show()    {        std::cout<
     
      <<" "<
      
       <<" "<
       
        <
       
      
     

输出结果为： 0 2 1

说明A并没有使用传入的参数进行初始化，

这是因为在虚基类中，我们假想会有多个子类向虚基类传递参数，为了避免这种情况，

在虚基类的情况下，禁止了子类C使用中间类B向虚基类A传递参数，此时调用的是A的默认构造函数。

那么我们该如何使用参数，初始化虚基类呢？

答案是我们可以在子类C中，直接调用虚基类A的构造函数进行初始化，如以下代码所示：

class A{private:    int a;public:    A(int n=0):a(n){}    int get(){
   return a;}};class B:virtual public A{private:    int b;public:    B(int m=0,int n=0):A(n),b(m){}    int get(){
   return b;}};class C:public B{private:    int c;public:    C(int q=0,int m=0,int n=0):A(m),B(m,n),c(q){}    int get(){
   return c;}    void Show()    {        std::cout<
     
      <<" "<
      
       <<" "<
       
        <
       
      
     

输出结果为： 3 2 1

跳过中间类，直接调用基类的构造函数，这种方式只适合虚基类。

在非虚基类中会报错“不允许使用间接非虚拟基类”。

 

参考资料：《C++ Primer.Plus》 pp.551-567