C++中的继承

1.继承的概念及定义

1.1继承的概念

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

1.2继承定义

1.2.1定义格式

下面我们看到 Person 是父类，也称作基类。 Student 是子类，也称作派生类。

1.2.2继承关系和访问限定符

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

|---------------------------------|-------------------|---------------------|-------------------|
| 类成员**/继承方式 | public 继承 | **protected继承** | **private**继承** |
| 基类的 public 成员 | 派生类的 public 成员 | 派生类的 protected 成员 | 派生类 private 成员 |
| 基类的 protected 成员 | 派生类的 protected 成员 | 派生类的 protected 成员 | 派生类 private 成员 |
| 基类的 private 成员 | 在派生类中不可见 | 在派生类中不可见 | 在派生类中不可见 |

总结：

基类 private 成员在派生类中无论以什么方式继承都是不可见的。这里的 不可见是指基类的私 有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面 都不能去访问它 。
基类 private 成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected 。 可以看出保护成员限定符是因继承才出现的 。
实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min( 成员在基类的访问限定符，继承方式 ) ， public > protected > private。
使用关键字 class 时默认的继承方式是 private ，使用 struct 时默认的继承方式是 public ，不过 最好显示的写出继承方式 。
在实际运用中一般使用都是 public 继承，几乎很少使用 protetced/private 继承，也不提倡使用protetced/private 继承，因为 protetced/private 继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

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

1. 派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用 。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。
2. 基类对象不能赋值给派生类对象。
3. 基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI(Run - Time Type Information)的 dynamic_cast 来进行识别后进行安全转换。

3.继承中的作用域

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

4.派生类的默认成员函数

6 个默认成员函数， " 默认 " 的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类中，这几个成员函数是如何生成的呢？

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

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

派生类的 operator= 必须要调用基类的 operator= 完成基类的复制，注意此时需要显示调用，因为派生类的operrator=和基类的operator=构成隐藏。

派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。

派生类对象初始化先调用基类构造再调派生类构造，因为派生类数据成员的初始化可能用到基类的数据成员，如果未初始化基类，此时基类数据成员全为随机值，初始化出错，并且需要在初始化列表显示调用基类的初始化。

派生类对象析构清理先调用派生类析构再调基类的析构，因为如果先调用基类的析构，后续可能会再次用到基类的成员，会出错，并且此时不需要显示调用基类的析构，派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。

因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同。那么编译器会对析构函数名进行特殊处理，处理成 destrutor() ，所以父类析构函数不加virtual的情况下，子类析构函数和父类析构函数构成隐藏关系。

5.继承与友元

友元关系不能继承 ，也就是说基类友元不能访问子类私有和保护成员。

6.继承与静态成员

基类定义了 static 静态成员，则整个继承体系里面只有一个这样的成员 。无论派生出多少个子类，都只有一个static 成员实例。

cpp 复制代码

#include<iostream>
#include<string>
using namespace std;
class Person
{
public:
	Person() { ++_count; }
protected:
	string _name; // 姓名
public:
	static int _count; // 统计人的个数。
};
int Person::_count = 0;//静态成员变量需要在类外初始化
class Student : public Person
{
protected:
	int _stuNum; // 学号
};
class Graduate : public Student
{
protected:
	string _seminarCourse; // 研究科目
};
void TestPerson()
{
	Student s1;
	Student s2;
	Student s3;
	Graduate s4;
	cout << " 人数 :" << Person::_count << endl; //4
	Student::_count = 0;
	cout << " 人数 :" << Person::_count << endl; //0
}
int main()
{
	TestPerson();
	return 0;
}

7.复杂的菱形继承

单继承：一个子类只有一个直接父类时称这个继承关系为单继承

多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承

菱形继承：菱形继承是多继承的一种特殊情况。

菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。 在 Assistant 的对象中 Person 成员会有两份。

数据冗余：有一些数据会存储两份在派生类中

二义性：对于从最顶部间接基类继承下来的变量，会有两份，当访问这个变量时，编译器无法确定你需要访问哪一个直接基类继承下来的变量。此时需要指定作用域才能解决

cpp 复制代码

class Person
{
public:
	string _name; // 姓名
};
class Student : public Person
{
protected:
	int _num; //学号
};
class Teacher : public Person
{
protected:
	int _id; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse; // 主修课程
};
void Test()
{
	Assistant a;
	// a._name = "peter"; // 这样会有二义性无法明确知道访问的是哪一个
	// 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
	a.Student::_name = "xxx";
	a.Teacher::_name = "yyy";
}
int main()
{
	Test();
	return 0;
}

8.虚继承

虚继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在 Student 和 Teacher 的继承 Person 时使用虚继承，即可解决问题。需要注意的是，虚继承不要在其他地 方去使用。 在继承时，在继承方式前面加上virtual关键字，此时的继承就变成了虚继承。虚继承的目的是让某个类做出声明，承诺愿意共享它的基类，这个被共享的基类就称为虚基类

cpp 复制代码

class Person
{
public:
	string _name; // 姓名
};
class Student : virtual public Person
{
protected:
	int _num; //学号
};
class Teacher : virtual public Person
{
protected:
	int _id; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse; // 主修课程
};
void Test()
{
	Assistant a;
	a._name = "peter";
}
int main()
{
	Test();
	return 0;
}

9. 虚继承解决数据冗余和二义性的原理

为了研究虚拟继承原理，我们给出了一个简化的菱形继承继承体系，再借助 内存窗口观察对象成
员的模型。

cpp 复制代码

class A
{
public:
	int _a;
};
class B : public A
{
public:
	int _b;
};
class C : 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;
}

下图是菱形继承的内存对象成员模型：这里可以看到数据冗余，B和C中都存有A

下图是菱形虚继承的内存对象成员模型：这里可以分析出 D 对象中将 A 放到的了对象组成的最下面，这个A 同时属于 B 和 C ，那么 B 和 C 如何去找到公共的 A 呢？这里是通过了在原先存放A的地方改为存一个指针，B和C中的该指针，指向一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量 可以找到下面的A。

当一个类继承到虚基类时，其会把虚基类放到类的末尾，将原本存储虚基类的区域换成一个虚基表指针，指向虚基表，虚基表内部存储着它们到虚基类成员的指针偏移量

虚继承后，对于BC类本身，它们创建出来的对象也通过虚基表这种方式来访问A了，这样可以保持访问的统一

对于多个同类型的变量，它们的结构是一致的，指针偏移量也是一致的，所以同一个类的所以对象共用一份虚基表，虚基表存在代码段。

10. 继承与组合对比

组合关系：

cpp 复制代码

class A
{};

class B
{
	A _aa;
};

组合关系是一个类作为另外一个类的成员。

继承关系：

cpp 复制代码

class A
{};

class B : public A
{};

继承关系和组合关系都可以实现代码的复用，继承关系可以直接将基类的成员继承到派生类中，让派生类直接访问。组合关系可以通过对成员变量的访问，来间接访问其他类的成员。

组合关系的耦合度比继承关系低，代码容易维护所以能用组合关系就尽量使用组合关系。

**1.**继承的概念及定义

1.1****继承的概念

1.2****继承定义

1.2.1****定义格式

1.2.2****继承关系和访问限定符

**2.**基类和派生类对象赋值转换

**3.**继承中的作用域

**4.**派生类的默认成员函数

**5.**继承与友元

**6.**继承与静态成员

**7.**复杂的菱形继承

8.虚继承

9. 虚继承解决数据冗余和二义性的原理

10. 继承与组合对比

1.继承的概念及定义

1.1继承的概念

1.2继承定义

1.2.1定义格式

1.2.2继承关系和访问限定符

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

3.继承中的作用域

4.派生类的默认成员函数

5.继承与友元

6.继承与静态成员

7.复杂的菱形继承