如何解决多重继承

​​例1​​

#include<iostream> 
using namespace std;

class A{
  public:
    void f();
};

class B{
  public:
    void f();
    void g();
};

class C : public A,public B{
  public:
    void g();
    void h();
};


int main(){
  
  C c1;
  c1.f();//具有二义性
  c1.g();//无二义性（同名覆盖）
  return 0;
}

具有二义性的错误显示（看下图的error部分）

解决方案

​​1、类名限定​​

c1.A::f();
c1.B::f();

​​2、同名覆盖​​

在class C中声明一个同名函数，该函数根据需要内部调用A的f()或者B的f()

​​例2​​

#include<iostream> 
using namespace std;

class B{
  public:
    int b;
};

class B1:public B{
  private:
    int b1;
};

class B2:public B{
  private:
    int b2;
};


class C : public B1,public B2{
  public:
    int f();
  private:
    int d;
};


int main(){
  
  C c1;
  c1.B1::b;//可以
  c1.B::b;//不行基类存在二义性（报错见下图）
  return 0;
}

例2这种情况的解决方案（虚基类）

虚基类：用于有共同基类的场合

声明
virtual修饰说明基类
主要用来解决多继承时，可能对同一基类继承，继承多次从而产生的二义性
为最远的派生类提供唯一的基类成员，而不重复产生多次拷贝

注意：需要再第一次继承的时候就要讲共同的基类设计为虚基类

具体改进代码见下面

#include<iostream> 
using namespace std;

class B{
  public:
    int b;
};

class B1: virtual public B{//改进处
  private:
    int b1;
};

class B2: virtual public B{//改进处
  private:
    int b2;
};


class C : public B1,public B2{
  public:
    int f();
  private:
    int d;
};


int main(){
  
  C c1;
  c1.B::b;//正确
  return 0;
}

补充

虚基类及其派生类构造函数

建立对象时所指定的类称为最（远）派生类
1、虚基类的成员是由派生类的构造函数 通过 调用虚基类的构造函数进行初始化的
2、在整个继承结构中，直接或者间接继承虚基类的所有派生类，都必须在构造函数的成员初始化表中给出对虚基类的构造函数的调用。
如果未列出，则表示调用该虚基类的缺省构造函数（default constructor就是默认构造函数）
3、在建立对象时，只有最派生类的构造函数调用虚基类的构造函数，该派生类的其他基类对虚基类的构造函数的调用被忽略

上诉描述过程见下面代码

#include<iostream> 
using namespace std;

class B{
  public:
    B(int n){
      nv = n;
      cout<<"I am B,my num is "<<nv<<endl;
    }
    
    void fun(){
      cout<<"Member of B"<<endl;
    }
  
  private:
    int nv;
};

class B1: virtual public B{
  public:
    B1(int x,int y):B(y){
      nv1 = x;
      cout<<"I am B1,my num is"<<nv1<<endl;
    }
  private:
    int nv1;
};

class B2: virtual public B{
  public:
    B2(int x,int y):B(y){
      nv2 = x;
      cout<<"I am B2,my num is"<<nv2<<endl;
    }
  private:
    int nv2;
};


class C : public B1,public B2{
  public:
    C(int x,int y,int z,int k):B(x),B1(y,y),B2(z,y){
      nvc = k;
    }
  private:
    int nvc;
};


int main(){
  
  C c1(1,2,3,4);
  c1.fun();
  return 0;
}

断点位置

经过调试

单步调试

然后就不能调试了（暂时还不知道原因？？？？）

若是采用单步跳过

直接跳到了55行代码，然后【单步调试】又调用基类中的函数

然后就不能调试了（暂时还不知道原因？？？？）