C++ 继承

前言

本文将会为你带来关于继承的相关知识（概念、定义、基类的成员变量访问形式、隐藏、父子类之间的赋值、派生类的默认成员函数、菱形继承与虚继承）

继承的概念以及定义

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

//父类Person
class Person
{
public:
	void Print()
	{
		cout << "name：" << _name << endl;
		cout << "age：" << _age << endl;
	}
protected:
	string _name = "peter"; //姓名
	int _age = 18; //年龄
};

//子类student
class Student : public Person
{
public:
	void func()
	{
		Print();
	}
protected:
	int _stuid; //学号
};

//子类teacher
class Teacher : public Person
{
protected:
	int _jobid; //工号
};
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

基类的成员变量在派生类中的访问形式

通过上面一个例子，我们可以观察到父类的成员有访问限定符的限制，而继承的时候
也会出现访问限定符，那这些组合在一起会有怎样的效果呢？



其中需要注意的是基类private成员在派生类无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它
基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在
派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
图中我们也可以观察到：基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)

剩下的组合需要大家一个个去尝试感受

//父类Person
class Person
{
//protected:
public:
//private:
	void Print()
	{
		cout << "name：" << _name << endl;
		cout << "age：" << _age << endl;
	}
protected:
	string _name = "peter"; //姓名
	int _age = 18; //年龄
};
//子类student
class Student : public Person
{
public:
	void func()
	{
		Print();
	}
protected:
	int _stuid; //学号
};
class Student : protected Person
{
public:
	void func()
	{
		Print();
	}
protected:
	int _stuid; //学号
};
//子类teacher
class Teacher : public Person
{
protected:
	int _jobid; //工号
};
int main()
{
	Student s;
	Teacher t;
	s.Print();
	//t.Print();
	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

隐藏

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

class person
{
protected:
	string _name = "小梨子";
	int _num = 111;
};
//stu派生类
class student : public person
{
public:
	void print()
	{
		//父类和子类可以有同名成员，因为他们是独立作用域
		cout << " 姓名:" << _name << endl;
		//隐藏
		cout << " 身份证号:" << person::_num << endl;
		cout << " 学号:" << _num << endl;
	}
protected:
	int _num = 999; //学号
};

class a
{
public:
	void fun()
	{
		cout << "func()" << endl;
	}
};

class b : public a
{
public:
	void fun(int i)
	{
		cout << "func(int i)->" << i << endl;
	}
};

void test()
{
	b b;
	b.fun(10);
	//error：b.fun();
	b.a::fun();
}

int main()
{
	student s;
	s.print();
	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
43
44
45
46
47
48
49
50
51
52
53
54
55
56

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

当类型转换的时候，会产生一个临时变量，而临时变量具有常性，但是如果是父类赋值给子类对象，我们认为这是天然的，中间不产生临时对象，不需要对父类对象加const，这个叫做父子类的赋值兼容规则，但是需要注意不能反过来赋值（即父类赋值给子类）

//父子类的赋值兼容规则
class Person
{
protected:
       string _name;
       string _sex;
       int _age;
};
class Student : public Person
{
public:
       int _No;
};
int main()
{
       //类型转换时，产生一个临时对象，具有常性，需要加const
       double d = 2.2;
       int i = d;
       const int& r = d;
       //类型转换时，产生一个临时对象，具有常性，需要加const
       string str = "xxxx";
       const string& rstr = "xxxx";
       //子类可以赋值给父类，它会把子类部分切割出来赋值给父类
       Student s;
       Person p = s;
       Person& rp = s;
       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

派生类的默认成员函数

1、 子类的构造函数必须调用父类的构造函数初始化基类的那一部分成员。如果父类没有默认的构造函数，则必须在子类构造函数的初始化列表阶段显示调用。 2、 子类的拷贝构造函数必须调用父类的拷贝构造完成基类的拷贝初始化。 3、 子类的operator=必须要调用父类的operator=完成基类的复制。 需要注意的是子类的析构函数在调用完成后会自动调用基类的析构函数清理基类成员，因为这样才能保证父类对象先清理子类成员再清理父类成员的顺序，因此不需要我们显示调用父类的析构函数 其中有一个疑问：为什么是先调用子类的析构再调用父类的析构呢，也就是说先清理子类的成员，再清理父类的成员，这样可能会存在风险：子类的析构函数里面是可以使用父类的成员的，如果先释放父类成员再调用子类析构函数的时候就会出问题

class Person
{
public:
       //构造
       Person(const char* name = "peter")
              :_name(name)
       {
              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;
       }
public:
       string _name;
};
//子类
class Student : public Person
{
public:
       //构造
       Student(const char* name, int id)
              :_id(id)
              //error：, _name(name)
              ,Person(name)
       {
              cout << "student(const char* name, int id)" << endl;
       }
       //拷贝构造
       Student(const Student& s)
              :Person(s)
              ,_id(s._id)
       {
              cout << "Student(const Student& s)" << endl;
       }
       Student& operator=(const Student& s)
       {
              cout << "Student& operator=(const Student& s)" << endl;
              if (this != &s)
              {
              		  person::operator=(s);
                      _id = s._id;
              }
              return *this;
       }
       //析构
       ~Student()
       {
              //Person::~Person();
              cout << "~Student()" << endl;
       }
protected:
       int _id;
};
int main()
{
       Student s1("张三", 18);
       Student s2(s1);       
       Student s3("李四", 19);
       s1 = s3;
       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
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

继承和静态成员

以下程序输出结果为3，基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论有多少个子类，都只有一个static成员实例

class Person
{
public:
       Person()
       {
              ++_count;
       }
protected:
       string _name;
public:
       static int _count;
};
int Person::_count = 0;
class Student : public Person
{
protected:
       int _stuNum;
};
Student func()
{
       Student st;
       return st;
}
int main()
{
       Person p;
       Student s;
       func();
       cout << Person::_count << endl;
}
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

菱形继承和虚继承

单继承：一个子类只有一个直接父类时称这个继承关系为单继承 多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承 菱形继承：菱形继承是多继承的一种特殊情况，有数据冗余和二义性的问题

如下代码中出现了virtual，virtual是什么意思呢，我们待会再谈

我们先来看看程序编译的结果：148行报了访问不明确的错误


我们透过监视窗口可以观察到a对象里面是存在两份person基类中的_name的成员变量的，a对象中出现了两份数据，这两份数据从基类继承过来，如果我们通过对象a直接访问_name，编译器并不知道你指的是小张还是老张这就会有二义性的问题，若是person中还涉及了人的身份证信息等，那么会导致a对象继承两份身份证信息，这必然会导致数据冗余，若是信息量一大，太过浪费内存空间

//多继承：菱形继承
class Person
{
public:
	string _name;
	int _age;
	int _tel;
};
//派生类stu
class Student : public Person
//class Student : virtual public Person
{
protected:
	int _num;
};
//派生类tea
class Teacher : public Person
//class Teacher : virtual public Person
{
protected:
	int _id;
};
//菱形继承
class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse;
};

void Test()
{
	Assistant a;
	a.Student::_name = "小张";
	a.Teacher::_name = "老张";
	a._name = "张三";
}
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

而virtual虚继承可以解决这个事情，注意：virtual加在直接继承person的位置，例如示例代码中加在了teacher类与student类并没有加在Assistant类
当我们加上在对应位置加上virtual后，再来透过监视窗口观察
这个时候a对象继承下来的基类成员都只存在一份，因此对一个地方成员的修改也会影响到其他类中的成员

小结

今日的分享就到这里啦，如果本文存在疏漏或错误的地方还请您能够指出