什么是二义性?

• 简单来说就是一个班级有两个同名的人都叫张三, 老师叫张三回答这道题, 这时, 谁都不知道老师指的是哪个张三, 这就是二义
• 多重继承的二义性就是在继承时，基类之间、或基类与派生类之间发生成员同名时，将出现对成员访问的不确定性——同名二义性
• 当派生类从多个基类派生，而这些基类又从同一个基类派生，则在访问此共同基类中的成员时，将产生另一种不确定性——路径二义性。

demo

#include <iostream>
#include <Windows.h>

using namespace std;

class Father {
public:
	Father() {}
	~Father() {}
	void play() {cout << "Father KTV唱歌！" << endl;}
};

class Mother {
public:
	Mother() {}
	~Mother() {}
	void play() {cout << "Mother 逛街购物！" << endl;}
};

class Son : public Father, public Mother{
public:
	Son() {}
	~Son() {} 
};

int main(void) {
	Son son;
	
	son.play(); //无法确定该调用Fther的play()还是Mother的play()
	
	system("pause");
	return 0;
}

解决多重继承的二义性的方法1:

使用 “类名::” 进行指定, 指定调用从哪个基类继承的方法!

    son.Father::play();
	son.Mother::play();

解决多重继承的二义性的方法2:

在子类中重新实现这个同名方法, 并在这个方法内部, 使用基类名进行限定,
来调用对应的基类方法

class Son : public Father, public Mother{
public:
	Son() {}
	~Son() {} 
	void play() { 
		Father::play(); 
		Mother::play(); 
	}
};

int main(void) {
	Son son;
	son.play();		//调用自己类内部重写的play()方法
	
	system("pause");
	return 0;
}

多继承

多继承：一个子类可能有多个父类(基类)。

多继承可能存在二义性问题：即如果继承的父类中出现同样的方法或者数据的时候，那么当子类去调用的时候会存在不知道调用谁的问题。

有问题的代码：

#include <iostream>

using namespace std;

class A {
public:
	A() {

	}

	~A() {

	}

	void play() {
		cout << "AAA" << endl;
	}

protected:
	int age = 12;
};

class B {
public:
	B() {

	}

	~B() {

	}

	void play() {
		cout << "BBB" << endl;
	}

protected:
	int age = 13;
};

class C: public A, public B {
public:
	C() {

	}

	~C() {

	}

	void test() {
		cout << age << endl;  // 存在二义性问题，编译器不知道该调用那个父类的
	}

};

int main() {
	C c1;
	c1.play();  // 存在二义性问题，编译器不知道该调用那个父类的
}

多继承二义性的解决方法：

1、子类访问父类成员数据可以指定父类名

2、子类访问父类方法可以指定父类名或者重写方法再调用父类方法

#include <iostream>

using namespace std;

class A {
public:
	A() {

	}

	~A() {

	}

	void play() {
		cout << "AAA" << endl;
	}

protected:
	int age = 12;
};

class B {
public:
	B() {

	}

	~B() {

	}

	void play() {
		cout << "BBB" << endl;
	}

protected:
	int age = 13;
};

class C: public A, public B {
public:
	C() {

	}

	~C() {

	}

	// 优雅的访问父类方法
	void play() {
		A::play();
		B::play();
	}

	void test() {
		cout << A::age << endl;  // 访问父类成员可以指定父类名
	}

};

int main() {
	C c1;
	c1.test();
	c1.play();  // 存在二义性问题，编译器不知道该调用那个父类的
	c1.A::play();  // 这种方法也可以不推荐

	return 0;
}

输入、输出：

多重继承

 多重继承：A的派生类B和C，B和C的派生类为D类。

多重继承(菱形继承)存在的问题也是二义性，当D类同时继承B和C的时候，那么该类中会同时存在两个同名的数据成员，分别属于B类和C类的。

解决法：

1、指定父类名

2、通过虚继承的方式解决

问题代码：

#include <iostream>

using namespace std;

class A {
public:
	A() {

	}

	~A() {

	}

protected:
	int age = 12;
};

class B : public A {

};

class C : public A {

};

class D : public B, public C {
public:
	void test() {
		age = 12; // 问题代码,存在歧义
	}
};


int main() {
	D d1;
	d1.test();

	return 0;
}

通过VS命令行参数查看对象的内存分布：

命令参数：/d1 reportSingleClassLayoutD

输出的内存分布：

可以看到内存分布中存在两个age

使用虚基类解决：

#include <iostream>

using namespace std;

class A {  // 虚基类
public:
	A() {

	}

	~A() {

	}

protected:
	int age = 12;
};

class B: virtual public A {  // 虚继承

};

class C : virtual public A {  // 虚继承

};

class D : public B, public C {
public:
	void test() {
		age = 13;
		cout << age << endl;
	}
};


int main() {
	D d1;
	d1.test();

	return 0;
}

 再次查看内存分布图其中只有一个数据

实际的业务场景中，一些事物会有多个属性。由此c++引入了，多重继承的概念，也就是允许一个派生类指定多个基类，这样就被叫做多重继承。

如下代码：

#include "stdafx.h"
#include <iostream>
#pragma warning(disable:4996)
#include <string>

using namespace std;

class car{
public:
	car(){
		cout << "this is car" << endl;
	}
	void print(void)
	{
		cout << "car class print" << endl;
	}
};

class truck:public car
{
public:
	truck(){
		cout << "this is truck" << endl;
	}
	void truck_print(void){
		cout << "truck::truck_print" << endl;
	}
};

class bus:public car
{
public:
	bus(){
		cout << "this is bus" << endl;
	}
	void bus_print(void){
		cout << "bus::bus_print" << endl;
	}
};

class train :public truck, public bus{
public:
	train(){
		cout << "this is train" << endl;
	}
	void train_print(void){
		cout << "train::train_print" << endl;
	}
};

int main(int argc, char *argv[])
{
	train test1;//多重继承的构造顺序和继承列表中基类的排列顺序一致，不是和它的初始化列表中的顺序
//一致，所以先执行truck中的构造函数，truck先执行car的构造函数。再执行bus中的构造函数，bus中先执行
//car中的构造函数
	/*this is car
this is truck
this is car
this is bus
this is train*/
	test1.train_print();//train::train_print
	test1.truck_print();//truck::truck_print
	test1.print();//出现二义性，print成员函数不明确。因为类bus和truck继承car的时候，都分别对
//car中的成员函数print做了一份拷贝。train在继承bus和truck时对bus和truck多了拷贝。所以
//test1.print()无法访问那个基类的print。
    car *p_car = &test1;//同样会产生二义性，将上面的继承按照下面的方法二，改为虚继承即可。

	return 0;
}

消除二义性的方法：

1.加上全局符指定使用哪一份拷贝。如：

test1.truck::print();                
test1.bus::print();

2.使用虚继承，这样的话。派生类train只有一份基类car的拷贝了。如：

将上面的

class truck:public car

class bus:public car

 改为:

class truck:virtual public car

class bus:virtual public car