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

在继承的过程中，如果一个派生类由多个基类派生，则称为多重继承（实际开发中会引入困难，不建议使用）

语法：

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

关系图：

多重继承的构造函数、析构函数调用顺序

构造函数：顺序与单继承一致，先基类、组合类、派生类新增加成员；

强调：

1、同一层基类的构造函数顺序取决于派生类声明继承基类时的基类先后顺序，与构造函数定义成员初始化列表顺序无关

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;
    }
}

输出：

b(int)构造函数

c(int)构造函数

d(int)构造函数

a(int)构造函数

~a()析构函数

~d()析构函数

~c()析构函数

~b()析构函数

2、组合类的成员对象的构造函数执行顺序取决于成员对象的声明顺序，与构造函数的初始化列表排列顺序无关

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;
    }
//...
}

输出：

b(int)构造函数

c(int)构造函数

d(int)构造函数

a(int)构造函数

~a()析构函数

~d()析构函数

~c()析构函数

~b()析构函数

析构函数：顺序与构造函数相反，先构造的后继承，形成对称

多重继承引发的二义性问题

问题1：继承同名成员

派生类继承多基类的同名成员

eg：

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;
}

作用域格式：

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

问题2：菱形继承（钻石继承）

两次继承三代成员：由一基类派生了两个第一代派生，而一类又共同继承了这两个一代派生形成二代派生

关系图：

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;
}

注意：

作用域标识符虽然可以解决二义性问题，但是在派生类中产生两个同名成员，增加了内存开销，解决方法间下方虚继承

多重继承的解决方法：

解决多重继承的命名冲突及数据冗余问题，c++中虚继承：使派生类只保留一份间接基类成员

1.虚继承（virtual）

格式：

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;
}

代码关系梳理：

虚继承（在继承的基类前加入virtual关键字），可以让声明虚继承的类作出声明，共享其基类（虚基类：virtual base class），使得不论虚基类 class a 被继承了多少次，派生类中只含有一份虚基类成员 m_a，节省内存空间，解决了成员名的歧义问题。

局限：

派生类只影响从指定的虚基类的派生类进一步派生出的后代类，而不会影响一代派生类本身

在实际开发中，位于中间层次的基类将其继承声明为虚继承一般不会带来什么问题。通常情况下，使用虚继承的类层次是由一个人或者一个项目组一次性设计完成的。对于一个独立开发的类来说，很少需要基类中的某一个类是虚基类，况且新类的开发者也无法改变已经存在的类体系。

c++标准库中的 iostream 类就是一个虚继承的实际应用案例。iostream 从 istream 和 ostream 直接继承而来，而 istream 和 ostream 又都继承自一个共同的名为 base_ios 的类，是典型的菱形继承。此时 istream 和 ostream 必须采用虚继承，否则将导致 iostream 类中保留两份 base_ios 类的成员。

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;

2.虚继承的二义性

虚继承要求在派生类中只包含一份虚基类数据，该数据在直接访问时无二义性问题

以菱形继承为例，判断是否存在其他二义性问题？

仅a 虚基类中定义成员变量 x，派生类d 直接访问 a类的x 成员（无二义性问题）
a、b类或 a、c 类中均含有成员变量x ，派生类访问 x 成员时，派生类x 优先级高于虚基类成员 x （无二义性）
a、b、c 中三个类均含有变量x ,派生类d访问时，b、c 类成员优先级一致（存在二义性问题）作用域标识符区分

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;//正确
    }
};