C++多重继承的二义性问题怎么解决？虚继承详解

class 派生类类名：继承方式1 基类名1 , 继承方式2 基类名2 ...
{
}

class A :public B,public C,public D
//基类的构造函数执行顺序为：B C D
{
public:
A (int d,int c,int b,int a):D(d),C(c),B(b),m_a(a)
{cout << "A(int)构造函数" << endl;}
//与构造函数初始化列表顺序无关
~A()
    {
        cout << "~A()析构函数" <<  endl;
    }
}

class A：public B
{
private:
    C c1;
    D d1;
    int a1;
    //取决于成员对象的声明顺序
public:
    //与初始化列表成员顺序无关
    A(int a,int b,int d,int c):a1(a),B(b),c1(c),d1(d)
    {cout << "A(int)构造函数" << endl;}
    ~A()
    {
        cout << "~A()析构函数" <<  endl;
    }
//...
}

class A
{
public :
void show()
{
    cout<<"A show()"<<endl;}
}
class B
{
public :
void show()
{
    cout<<"B show()"<<endl;}
}
class C
{
public :
void showc()
{
    cout<<"C showc()"<<endl;}
}

int main()
{
    C c;
    //error:
    //c.show()  
    //二义性：不知道此时c 该执行A类的show还是B类的show函数
    return 0;
}

int main()
{
    C c;
    //解决方法：
    c.A::show();
    c.B::show();
    c.showc();
    return 0;
}

对象名.基类名::成员变量名;
对象名.基类名::成员函数名（参数列表）;

class A //间接基类,第一层的类
{
protected:
    int m_a;
};
class B :public A //直接基类B
{
protected:
    int m_b;
//继承m_a;
};
class C :public A //直接基类C
{
protected:
    int m_c;
//继承m_a;
};

class D:public C,public B
{
public:
void set(int a)
{
 //继承m_a;
    //error:  m_a=a;
    //不知道赋值给B 类的还是C类的m_a；
}
...

void set(int a)
{
    B::m_a=a;
    C::m_a=a;
}
protected:
    int m_d;
//继承 m_a 源于B;
//继承 m_b 源于B;
//继承 m_a 源于C;
//继承 m_c 源于C;
};
int main()
{
    D d;
    return 0;
}

class      A   : virtual  public    B
class 派生类类名：virtual 继承方式 基类类名

//多重继承 虚继承
#include <iostream>
#include <string>
using namespace std; 
class A
{
public :
	int m_a;
};
class B:virtual public A
{
public:
	int m_b;
	//虚继承 m_a
};
class C :virtual public A
{
public:
	int m_c;
	//虚继承 m_a
};
class D:virtual public A
{
public:
	int m_d;
	//虚继承 m_a
};
class E :public C, public B
{
public :
	int m_e;
	//虚继承 m_a
	//继承 m_b
	//继承 m_c
	void seta(int a) { m_a = a; }//正确
	void setb(int b) { m_b = b; }//正确
	void setc(int c) { m_c = c; }//正确
	void setd(int d) { m_d = d; }//正确
	void setd(int e) { m_e = e; }//正确
};
int main()
{
	E e;
	return 0;
}

using istream  = basic_istream<char, char_traits<char>>;
using ostream  = basic_ostream<char, char_traits<char>>;
using iostream = basic_iostream<char, char_traits<char>>;
class basic_istream  : virtual public basic_ios;
class basic_ostream  : virtual public basic_ios;
class basic_iostream : public basic_istream,
public basic_ostream;

class A //间接基类
{
protected:
    int x;
};
class B :virtual public A //直接基类B
{
protected:
    int x;
};
class C :virtual public A //直接基类C
{
protected:
    int x;
};
class D :public B, public C //派生类D
{
public:
    void setx(int a) 
    {
        //x = a;//错误,有二义性
        //添加作用域标识符
        B::x = a;//正确
        C::x = a;//正确
    }
};