C++学习之多继承_c++多继承-CSDN博客

本文链接：https://blog.csdn.net/qq_61422622/article/details/133863744

本文详细探讨了C++中的继承机制，包括不同类型的继承（private,protected,public）、默认成员函数的生成与调用规则、友元与静态成员的特性，以及菱形继承和虚继承的优缺点。强调了组合类在复用和耦合度上的优势，并提倡在多继承时避免菱形继承问题。

摘要由CSDN通过智能技术生成

一，继承的特点

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

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

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

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

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

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

基类对象不能赋值给派生类对象。

派生类的默认成员函数

6 个默认成员函数， “ 默认 ” 的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类

中，这几个成员函数是如何生成的呢？

1.派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员，如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。

2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。

3. 派生类的operator=必须要调用基类的operator=完成基类的复制。

4. . 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认

派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能

保证派生类对象先清理派生类成员再清理基类成员的顺序。

5. 派生类对象初始化先调用基类构造再调派生类构造。

6. 派生类对象析构清理先调用派生类析构再调基类的析构。

7. 因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同(这个我们后面会讲

解)。那么编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加

virtual的情况下，子类析构函数和父类析构函数构成隐藏关系

简单来说父类默认没写的，子类会自动调用，父类显示写了的，在子类当中需要去显示的调用。

继承与友元

一句话：友元关系不能被继承，子类访问不到夫类的友元函数。（本质上友元函数是在类外声明定义的，不是成员函数）

继承与静态成员

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

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

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

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

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

菱形继承

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

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

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

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的内存窗口

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