c++继承

🍇继承
  🍈各种继承访问方式的区别
  🍏基类和派生类的类型转换——切片
    🍐规则
    🥝示例
  🍎继承中作用域——隐藏
    🍒规则
    🍓示例
  🫒派生类默认成员函数
    🥦规则
    🫑示例
    🥒辨析
  🍋虚继承
    🍌菱形继承
    🍍虚继承原理——内存
  🥭继承小知识

🌄继承

🌅各种继承访问方式的区别

public和protect成员——访问权限取小的（即public使用private方式继承，访问权限是private，也就是只能类内访问）
private成员变量不论使用任何方式继承都是不可见的

🚦各基类和派生类的类型转换——切片

🚧规则

子类对象可以赋值给父类的对象/指针/引用，并且中间不产生临时变量——父子类的赋值兼容规则——这种规则也通常叫做切片

🛑示例

1. 父类对象 = 子类对象

class Base
{
public:
	int _a = 20;
};
class Son :public Base
{
public:
	int _b = 30;
};
int main()
{
	// 对象 = 对象
	Base b;
	Son s;
	s._a = 30;
	b = s;// 如果成功切片，最终的b._a应该是30

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2. 父类指针 = &子类对象

class Base
{
public:
	int _a = 20;
};
class Son :public Base
{
public:
	int _b = 30;
};
int main()
{
	// 父类指针 = &子类对象
	Son s;
	s._a = 30;
	Base* b = &s;// 如果成功切片，最终的b._a应该是30

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3. 父类引用 = 子类对象

class Base
{
public:
	int _a = 20;
};
class Son :public Base
{
public:
	int _b = 30;
};
int main()
{
	// 父类引用 = 子类对象
	Son s;
	s._a = 30;
	Base& b = s;// 如果成功切片，最终的b._a应该是30

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

⛵继承中作用域——隐藏

🛶规则

隐藏——子类成员和父类成员同名，导致在子类中无法直接访问到父类成员的问题（也叫做重定义）
对于函数而言，只需要函数名相同即可构成隐藏，不需要考虑参数、返回值
如果想使用父类的成员，需要使用类型::成员进行调用

🚤示例

class Base
{
public:
	void print()
	{
		puts("Base");
	}
	int _a = 20;
};
class Son :public Base
{
public:
	void print()
	{
		puts("Son");
	}
	void fun()
	{
		print();
	}
	int _b = 30;
};
int main()
{
	Son s;
	s.fun();

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

✈派生类默认成员函数

🛫规则

🛬示例

class Person
{
public:
	// 初始化列表不能对成员变量重复初始化
	// 初始化列表如果有，他会先走初始化列表，如果没有初始化完，再走定义成员变量；如果初始化列表初始化完了，不走成员变量定义
	Person()
		:_name("perter")
		,id(1)
	{
		cout << "Person()" << endl;
	}
	Person(int id,const char* name ="perter")
		: _name("aaa")
	{
		cout << "Person()" << endl;
	}

	Person(const Person& p)
		: _name(p._name)
	{
			cout << "Person(const Person& p)" << endl;
	}

	Person& operator=(const Person& p)
	{
		cout << "Person operator=(const Person& p)" << endl;
		if (this != &p)
			_name = p._name;

		return *this;
	}

	~Person()
	{
		cout << "~Person()" << endl;
	}
protected:
	int id = 0;
	string _name="asdf"; // 姓名
};
class Student : public Person
{
public:
	Student(const char* name, int num)
		: _num(num)
		,Person(1,name) // 如果有显示调用就走显示调用
	{
		//Person::Person(name);// 不能初始化函数中显示调用父类的构造函数
		// 子类成员函数会在运行函数之前检查函数列表是否调用父类的构造函数
		// 如果有父类的构造函数会先进行父类的构造函数
		// 如果没有会默认调用父类的构造函数
		cout << "Student()" << endl;
	}
	// 构造函数才是基础，对于赋值运算符而言，相当于是父类已经是有了，但是没有赋值，我们需要显示调用进行赋值
	// 需要从Student中拿到父类成员的那部分，就可以使用切片操作
	Student(const Student& s)
		: Person(s) // 子类对象赋值给父类的引用——就可以完成父类的拷贝
		, _num(s._num)
	{
		cout << "Student(const Student& s)" << endl;
	}

	Student& operator = (const Student& s)
	{
		cout << "Student& operator= (const Student& s)" << endl;
		if (this != &s)
		{
			Person::operator =(s);
			_num = s._num;
		}
		return *this;
	}
	void print()
	{
		cout << _name << endl;
	}

	~Student()
	{
		//~Person();// 显示调用析构函数——报错
		//Person::~Person(); // 同样的问题，不能在函数体中显示调用父类的析构函数
		// 析构函数会进行特殊的处理 destrutor()
		cout << "~Student()" << endl;
	}
protected:
	int _num=10; //学号
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

我来稍微解释一下

1. 在构造函数的初始化列表中显示调用父类的构造函数Person(xxx)
2. 在拷贝构造中为什么可以直接传入另一个子类的对象呢？？？
    因为切片的原因，父类得到的是子类的切片，刚好是一个父类对象
3. 在operator=重载时，不能直接调用operator=，需要指明调用的域，Person::operator=()

🪂辨析

1. 构造函数必须要在初始化列表中调用，为什么不能在构造函数内部调用

继承是现有父类再有子类，如果已经进入了构造函数内部，证明已经有了子类，正在初始化子类，这个时候再去构造父类就已经晚了；
这也就是为什么operator=可以在函数内部调用，operator=是先有对象然后才有这个运算符重载；虽然可以理解为父类对象已经有了，但是父类对象的成员没有进行赋值，所以需要显示调用

2. 构造函数初始化列表的一些细节

1. 初始化列表不能重复初始化同一个成员变量
2. 在初始化阶段，编译器是知道应该先先初始化那个变量的——先声明先初始化
   那么他就会根据声明顺序去缺省值---> 初始化列表 ---> 声明定义处初始化

🚀虚继承

🛸菱形继承

菱形继承会带来数据冗余的问题为了解决问题有了虚继承

🛎虚继承原理——内存

#include
#include
using namespace std;

class Person
{
public:
	int _a = 5;
	int _age; // 姓名
};
class Student : virtual public Person
{
protected:
	int _num; //学号
};
class Teacher : virtual public Person
{
protected:
	int _id; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected:
	int _c=3; // 主修课程
};
void Test()
{
	// 这样会有二义性无法明确知道访问的是哪一个
	Assistant a;
	//a._name = "peter";
	// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
	a.Student::_age = 1;
	a.Teacher::_age = 2;
	a.Student::_a = 1;
	a.Teacher::_a = 2;
	cout << sizeof(a) << endl;
}
int main()
{
	Test();
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

virtual继承中，每个继承中存一个虚基表指针，指针指向产生冲突的类
虚基表指针指向的第二行才是偏移量
第一行是多态要用的

如果是奇葩继承，只需要记住，在产生冲突的地方继承

🎊继承小知识

1. 实现一个不能继承的类

1. c++98——将构造函数私有化
2. c++11——使用final关键字

2. 友元不能被继承（就像父亲的朋友不是你的朋友一样）
3. 继承——白盒复用
 组合——黑盒复用
4. 先继承先声明

class A
{
public:
	A(int a) { cout << "A" << endl; }
};
class B : virtual public A
{
public:
	B(int a,int b):A(a) { cout << "B" << endl; }
};
class C :virtual public A
{
public:
	C(int a,int c):A(a) { cout << "C" << endl; }
};
class D :public C,public B
{
public:
	D(int a,int b,int c,int d):B(a,b),C(a,c),A(a){ cout << "D" << endl; }
};
int main()
{
	D d(1, 2, 3, 4);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

使用virtual继承，他们共同继承一个祖宗，首先构造的是祖宗；D首先继承的是C，所以紧接着要构造C；最后构造B

$自问时间$

1. 切片的语法
2. 什么是隐藏
3. 什么是菱形继承
4. 菱形继承如何解决
5. 虚继承原理