C++学习之多继承

目录

一，继承的特点

继承基类成员访问方式的变化

基类和派生类对象赋值转换

派生类的默认成员函数

继承与友元

继承与静态成员

复杂的菱形继承及菱形虚拟继承

菱形继承

虚继承

虚继承的底层实现

多继承的例子：

多继承与组合类

多继承总结：

---

一，继承的特点

继承基类成员访问方式的变化

 简单的来说，私有数据无论是哪种继承方式，继承下来的私有数据都是隐藏的，无法使用的，

protected继承下来的数据只能用基类的成员函数访问，public继承下来的公有还是公有。

基类和派生类对象赋值转换

完成继承后，在初始化的时候，我们可以通过派生类来赋值给基类的对象 / 基类的指针 / 基类的引用。

我们可以理解为将派生类切片，切掉继承来的那一部分，将那一部分可以赋值给一个父类对象/父类指针/父类的引用

派生类的默认成员函数

继承与友元

继承与静态成员

一句话：静态成员不算是被子类继承，子类和父类共享这一份静态成员数据。

复杂的菱形继承及菱形虚拟继承

首先我们知道单继承---一个类继承另一个类，算作是单继承：

 而对于多继承来说，是一个类同时继承了一个以上的类：

多继承在上述的方式都是合理的，正常使用。

菱形继承

而菱形继承是一种特殊的多继承：

但是此时的菱形继承区有一个大坑：

我们知道子类会继承父类的数据，但若子类多继承的父类同时拥有上一继承的类的同一份数据？即菱形继承的最底下这个类拥有两份上上层类的数据。那么在最底下这个类访问的时候就会重现访问冲突这样的问题。

class Person
{
public:
	Person(string name)
	{
		this ->name = name;
	}
	string name; // 姓名
};
class Student : public Person
{
public:
	Student(int num,string name):Person(name)
	{
		this->_num = num;
	}
	int _num; //学号
};
class Teacher :public Person
{
public:
	Teacher(int num, string name):Person(name)
	{
		this->_num1 = num;
	}
	int _num1;//职工编号
};
class Assistant :public Student, public Teacher
{
public:
	Assistant(int num, int num1, string name1, string name2, string course) :Student(num, name1), Teacher(num1, name2)
	{
		this->course = course;
	}
	string course;//学习课程
};
void Test()
{
 
	string name = "张三";
	string name1 = "李四";
	string couse = "生物";
	Assistant A(001, 002, name, name1,couse);
	cout << A.name << endl;
}

当我们成功初始化A的时候，再次调用他的name，那就会说，访问不明确。那是因为在继承的时候student与teacher类都具有name，此时直接访问就会产生二义性，编译器报错不明确的name，当然我们还是可以解决这个办法：

通过作用域确定我们访问的name：

void Test()
{
	string name = "张三";
	string name1 = "李四";
	string couse = "生物";
	Assistant A(001, 002, name, name1,couse);
	//cout << A.name << endl;
	cout << A.Student::name << endl;
	cout << A.Teacher::name << endl;
}

那么二义性的问题得到了解决，但是数据冗余的问题得不到解决，那么当被继承的类若果数据够大的话，反而与用继承实现代码复用的初心背道而驰，大大浪费了空间。

虚继承

那么该如何解决呢？经过祖师爷们的苦思冥想，c++在之后提供了一个关键字vitual，我们在菱形继承的第一次继承时采用虚继承的方式，这样数据冗余与二义性的问题都得到了解决：

 我们将上述代码使用虚继承修改之后：

class Person
{
public:
	Person(string name)
	{
		this ->name = name;
	}
	string name; // 姓名
};
class Student :virtual public Person
{
public:
	Student(int num,string name):Person(name)
	{
		this->_num = num;
	}
	int _num; //学号
};
class Teacher :virtual public Person
{
public:
	Teacher(int num, string name):Person(name)
	{
		this->_num1 = num;
	}
	int _num1;//职工编号
};
class Assistant :public Student, public Teacher
{
public:
	Assistant(int num, int num1, string name, string course) :Student(num, name), Teacher(num1, name),Person(name)
	{
		this->course = course;
	}
	string course;//学习课程
};
void Test()
{
	string name = "张三";
	string course = "生物";
	Assistant A(001, 002, name, course);
	cout << A.name << endl;
}

此时可以看到我们是可以直接访问到name的，我们对于最后继承的类也要添加最初父类的构造函数，否则报错，这是为什么呢？

虚继承的底层实现

这就要看我们虚继承的底层实现了。

我们首先简单的看一下name的地址：

此时发现name只有一份了，Student与Teacher的name是一样的了，即只有一份name了，我们还可以侧面证明：

void Test()
{
	string name = "张三";
	string course = "生物";
	Assistant A(001, 002, name, course);
	A.Student::name = "李四";
	A.Teacher::name = "王五";
	cout << A.name << endl;
}

再次显示给stdent和teacher的name，结果是输出王五，将student与teacher给的名字交换一下，输出又变成李四，由此可以得出，name只有一份，输出的是最后name赋值的新值，也就是name最后的更新。

为了更好的分析，我们写一个简化了的菱形虚拟类：

class A
{
public:
	int _a;
};
class B : virtual public A
{
public:
	int _b;
};
class C :virtual public A
{
public:
	int _c;
};
class D :public B, public C
{
public:
	int _d;
};
int main()
{
    D d;
	d.B::_a=1;
	d.C::_a=2;
	d._b = 3;
	d._c = 4;
	d._d = 5;
    return 0;
}

之后再观察内存窗口：&d的内存窗口

我们的成员变量是整形，四个字节，因此一行的地址代表一个成员变量。

刚执行完_a=1;所以这里的0x0000007c710FFB60就是我们的_a，

执行完_a=2,这里的_a就是2了，这两行运行完又证明了虚继承之后_a，是只有一份的。

执行完_b=3时，此时的内存地址一跃而上来到了0x0000007c710FFB40，其值为3

执行完_c=4时，内存地址又往下走了，来到了0x0000007c710FFB50，其值为4

执行完_d=5，内存还是往下走，来到了0x0000007c710FFB58，其值为5.

之后我们去掉虚继承，再看此时的_a：

 只看_a的话我们可以看到_a的地址发生了变化，即这里是两个_a，分别存储了值。

其次他的内存一直是递增的，而我们虚继承不是。

再次观察运行完之后的两者的d对象的内存：

我们发现不用虚继承时B中就是_a与_b，同理C,之后就是_d，内存是递增的。

当用虚继承时，_a的内存被单独拿出来也就是A中的内存，且被放在了这一块地址最后面，而B和C没有了_a,却多了一个不知名的地址。之后就是D，里面有一个_d。

对于这里的不知名地址又是啥呢？

对于我们之前学习继承，我们可以用子类对象去赋值父类对象，父类指针，父类引用。那是因为地址是按声明顺序存储，我们很容易切片内存而找到父类的那一部分，但此时用了虚继承之后，内存反而不是如此的顺序，切片也就更加困难，那我们该如何解决这个问题呢？

因此我们需要找到该地址的偏移量，通过偏移量来计算出此时对于这里A的地址，所以真相就是不知名的地址存放了一些信息，包括了对于这里来说就是距离A的偏移量。

除了对象d，我们创建B的一个对象bb，bb._a=1;bb._b=2;

可以看到此时B里的也是如此，f6 7f 00 00..对应的地址就是存放了距离A的偏移量。

通过存放偏移量（虽然还是少量的增加了空间消耗），实现了继承了父类成员不在数据冗杂，且不存在二义性。

多继承的例子：

对于我们的io流，实际上就实现了一个菱形继承：

istream继承ios，ostream继承ios，iostream多继承istream与ostream。

多继承与组合类

多继承总结：

那么对于我们，在使用多继承的时候，最好就不要使用菱形继承（对于不是对自己的实力很相信的），我们就使用多继承就行，但不要使用这种特殊的继承。