C++基础知识之"继承概念"

发表于 | 分类于
在C++中的继承，很重要哟！

fengjingtu

面向对象程序设计有4个主要特点：抽象、封装、继承和多态性。

继承性是面向对象程序设计最重要的特征，可以说，如果没有掌握继承性，就等于没有掌握类和对象的精华，就是没有掌握面向对象程序设计的真谛。

类之间的关系

has-A，uses-A 和 is-A三种关系。

has-A：包含关系，用以描述一个类由多个“部件类”构成。实现has-A关系用类成员表示，即一个类中的数据成员是另一种已经定义的类。

uses-A :一个类部分地使用另一个类。通过类之间成员函数的相互联系，定义友员或对象参数传递实现。

is-A: 机制称为“继承”。关系具有传递性,不具有对称性。

继承相关概念

继承：是类之间定义的一种重要关系。

一个B类继承A类，或称从类A派生类B，类A称为基类或者父类，类B称为派生类或者子类。

派生类的定义

类继承关系的语法形式：

1
2
3
4
class 派生类名:基类名
{
	数据成员和成员函数声明
}

基类名表构成
​ 访问控制 基类名1，访问控制 基类名2，……访问控制 基类名n

访问控制表示派生类对基类的继承方式使用关键字：

public：公有继承

private：私有继承

protected：保护继承

派生类的访问控制

说明：

子类拥有父类的所有成员变量和成员函数

子类可以拥有父类没有的方法和属性

子类就是一种特殊的父类

子类对象可以当作父类对象使用

派生类继承了基类的全部成员变量和成员方法（除了构造和析构之外的成员方法），但是这些成员的访问属性，在派生过程中是可以调整的。

C++中的继承方式会影响子类的对外访问属性
public继承：父类成员在子类中保持原有访问级别
private继承：父类成员在子类中变为private成员
protected继承：父类中public成员会变成protected
​ 父类中protected成员仍然为protected
​ 父类中private成员仍然为private
private成员在子类中依然存在，但是却无法访问到。不论种方式继承基类，派生类都不能直接使用基类的私有成员。

C++中的继承方式会影响子类的对外访问属性
public继承：父类成员在子类中保持原有访问级别
private继承：父类成员在子类中变为private成员
protected继承：父类中public成员会变成protected
​ 父类中protected成员仍然为protected
​ 父类中private成员仍然为private

private成员在子类中依然存在，但是却无法访问到。不论种方式继承基类，派生类都不能直接使用基类的私有成员 。

“三看”原则

C++中的继承方式（public、private、protected）会影响子类的对外访问属性

判断某一句话，能否被访问

1）看调用语句，这句话写在子类的内部、外部

2）看子类如何从父类继承（public、private、protected）

3）看父类中的访问级别（public、private、protected）

派生类类成员访问级别设置的原则

思考：如何恰当的使用public，protected和private为成员声明访问级别？

1、需要被外界访问的成员直接设置为public

2、只能在当前类中访问的成员设置为private

3、只能在当前类和子类中访问的成员设置为protected，protected成员的访问权限介于public和private之间。

练习

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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
#include<iostream>

using namespace std;

//类的继承基础
class Father
{
private :
public:
	int a;
	int b;
	void printF()
	{
		cout << "a=" << a;
		cout << "b=" << b;
	}

};
//class Son :public Father
//class Son :protected Father
//class Son :private Father
class Son :public Father
{
private :
	int c;
public:
	void setSon(int a, int b,int c)
	{
		this->a = a;
		this->b = b;
		this->c = c;
	}
	void printS()
	{
		cout << "a=" << a<<endl;
		cout << "b=" << b<<endl;
		cout << "c=" << c<<endl;
	}

};

void inherit_test1()
{
	Son son1;
	son1.setSon(10, 11,12);
	son1.printS();

}

//访问控制
//三看原则：
//1）看调用语句，这句话写在子类的内部、外部
//2）看子类如何从父类继承（public、private、protected）
//3）看父类中的访问级别（public、private、protected）

//private:类内部使用
//protected:类内部和派生类中使用,是为了继承为了在家族中使用的！！！
//public:类内类外都可以使用
class Father2
{
private://只有自己知道
	int a;
protected://家庭人员可知道
	int b;
public:
	int c;//所有人都可以知道
public:
	void printF()
	{
		cout << "a=" << a;
		cout << "b=" << b;
		cout << "c=" << b;
	}

};
//class Son :public Father 父类的成员除了private不能访问之外，其他保持原样
class Son1 :public Father2
{
private:
public:
	void setSon()
	{
		//a = 0;//error 
		b = 0;//protected
		c = 0;//public
	}
};
//class Son :protected Father类的成员除了private不能访问之外，其他保持变为自己的protected
class Son2 :protected Father2
{
private:
public:
	void setSon()
	{
		//a = 0;//error 
		b = 0;//protected
		c = 0;//protected
	}

};
//class Son :private Father父类的成员除了private不能访问之外，其他保持变为自己的private
class Son3 :protected Father2
{
private:
public:
	void setSon()
	{
		//a = 0;//error 
		b = 0;//private
		c = 0;//private
	}

};


void inherit_test2()
{
	Son1 son1;
	//son1.a = 0;//error
	//son1.b = 0;
	son1.c = 0;
	Son2 son2;
	//son2.a = 0;//error
	//son2.b = 0;//error
	//son2.c = 0;//error
	Son3 son3;
	//son3.a = 0;//error
	//son3.b = 0;//error
	//son3.c = 0;//error
}



//派生类访问控制权限的设置原则
//一般情况下都是public继承

int main_inherit_test2()
{
	inherit_test2();
	cout<<"hello world"<<endl;
	system("pause");
	return 0;
}