C++之继承＜1＞【详解】

1. 继承的概念

  继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。

  通俗意义上来理解，继承就像是传统习俗一样，子女会继承父母的一些特征，财产等等，一个人在刚刚出世的时候你不能指望他像他父母一样拥有工作的能力去帮助你完成某些事情，如果让你来培养他直到能够达到工作能力以后，可想而知需要花费多大的力气。就像计算机世界一样，你想快速轻松的获得一个具备完成某项任务的对象，但又不想花费精力编写一些重复的代码，这时候就可以用到继承。
  比如你想编写两个类分别是：学生类和老师类，编写其中的属性的时候发现，两个类中都有一些相同的属性，比如：姓名，性别，年龄，或者相同的行为，比如：吃饭，运动。两个类中都写的话显得冗余，就可以将其中相同的属性和行为提取出来，放入一个person类中，并且令学生类和老师类继承person类，这时学生类和老师类中可以不用写出这些属性和行为但是都分别拥有它们。其中，学生类和老师类叫做子类或者派生类，person类叫作父类或者基类。
  下面是代码体现：

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
class person
{
public:
	std::string name;
	int age;
	int gender;

	void sport()
	{
		printf("运动。。。\n");
	}

	void eat()
	{
		printf("吃饭。。。\n");
	}
};

class student : public person
{

};

class teacher : public person
{

};

int main()
{
	student st;
	st.sport();
	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

  可以看到即使student类中没有编写任何代码，但是实际上已经继承了person的属性和行为。

2. 继承定义的格式

2.1 继承方式和访问限定符

• 继承方式
  1. public继承
  2. protected继承
  3. private继承
• 访问限定符
  1. public访问
  2. protected访问
  3. private访问

2.2 继承了基类成员后随着访问方式变化的变化

 理解上面的这张图：
   1. 基类中的private成员无论是什么继承方式，继承以后在派生类中都不可见。
      1.1这里的不可见只是派生类对象无论在类里面还是类外面都无法访问它，但是基类中的private成员还是继承到了派生类中，只是“不可见”。

   2. 基类中的其他成员继承后在派生类中的访问方式=Min(成员在基类中的访问方式，继承方式）

   3. protected就是为了继承而生的。当基类中的成员继承后不想被类外被访问但是想在类中可以访问，可以将这个基类成员设置为protected修饰，或者使用protected继承方式（但是使用protected继承后可能会将一些不希望设置为protected的public基类成员变成protected）。

   4. 使用关键字class时默认的继承方式是private，使用关键字struct时默认的继承方式是public，也就是说可以不用显式的写出继承方式，但是最好还是显示的写出来。

class person
{
public:
	std::string name;
	int age = 23;
	int gender;

	void sport()
	{
		printf("运动。。。\n");
	}

	void eat()
	{
		printf("吃饭。。。\n");
	}
};

class student :  person
{
public:
	void getAge()
	{
		printf("studentAge : %d\n", age);
	}
};

int main()
{
	student st;
	st.getAge();
	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

   5. 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

3. 基类和派生类对象的复制转换

• 派生类对象可以赋值给基类的对象 / 基类的指针 / 基类的引用。这个操作叫做切片或者切割。也就可以形象的看作是将派生类中属于基类中的那部分属性和行为“切割”出来赋值给基类。
  
  红色的部分就是基类person和派生类student共有的属性，黄色的部分是派生类继承后声明的变量，只属于派生类student。

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

• 基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用，但是必须是基类的指针指向派生类对象时才是安全的。

class person
{
public:
	std::string name;
	int age = 23;
	int gender;

	void sport()
	{
		printf("运动。。。\n");
	}

	void eat()
	{
		printf("吃饭。。。\n");
	}
};

class student : public person
{
public:
	int study() 
	{ 
		
		printf("学生在学习。。。\n");
	}

	
	
};

int main()
{
	student st;
	
	//派生类对象可以赋值给基类的对象 / 基类的指针 / 基类的引用
	person ps = st;
	person* ps_ptr = &st;
	person& rps = st;

	//基类对象不能赋值给派生类对象。
	person pss;
	st = pss;

	//基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用，
	//但是必须是基类的指针指向派生类对象时才是安全的。
	person* pss_ptr = &st;
	student* pst = (student*)pss_ptr;

	//虽然不会报错，但是存在越界访问的问题。
	person pps;
	person* pps_ptr = &pps;
	student* ppst = (student*)pps_ptr;

	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
43
44
45
46
47
48
49
50
51
52
53
54
55
56

5. 隐藏

1. 在继承体系中基类和派生类都有独立的作用域。
2. 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏， 也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
4. 注意在实际中在继承体系里面最好不要定义同名的成员。

• 区别隐藏和重载： 隐藏是作用于两个作用域的，重载是作用域一个作用域的。

class person
{
public:
	std::string name;
	int age = 23;
	int gender;

	void sport()
	{
		printf("运动。。。\n");
	}
};

class student :  person
{
public:
	void getAge()
	{
		printf("studentAge : %d\n", age);
	}

	int age = 87;
};

int main()
{
	student st;
	st.getAge();//输出结果是87
	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

---

class person
{
public:
	std::string name;
	int age = 23;
	int gender;

	void sport()
	{
		printf("运动。。。\n");
	}

};

class student : person
{
public:
	int sport(int n)
	{
		printf("打篮球。。。\n");
		return n;
	}
};

int main()
{
	student st;
	st.sport(34);//输出结果是87
	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

上面代码说明，对于成员函数，只要函数名相同就构成隐藏。

  😄 创作不易，你的点赞和关注都是对我莫大的鼓励，再次感谢您的观看😄