C++继承

本期我们来学习继承，继承是面向对象的三大特性之一

目录

概念及定义

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

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

继承中的作用域

派生类的默认成员函数

继承与友元

继承与静态成员

复杂的菱形继承及菱形虚拟继承

继承的总结和反思

---

概念及定义

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

 举个例子，我们要写一个学校管理系统，我们要管理每一个人的信息，要定义学生类，老师类，图书管理员类，保安类等等，这些人都有自己的特有信息，还有共同的信息，比如所有类都有姓名，年龄，电话等等，如果我们在每一个类里面都写这些，那太麻烦了，于是就有了继承

我们可以写一个person类，这个类里面就有名字，年龄，电话，其他的类继承这个类即可，比如老师类继承person类，然后可以有自己独有的教职工号等等，继承的本质就是复用

继承的格式是中间加一个冒号，被继承的类叫做父类或者基类，继承的类叫做子类或者派生类

下面我们来写段代码

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

class Student : public Person
{
protected:
	int _stuid; // 学号
};

class Teacher : public Person
{
protected:
	int _jobid; // 工号
};
int main() {
	Student s;
	Teacher t;
	s.Print();
	t.Print();
	return 0;
}

 

 我们可以看到，我们没有在学生类里面定义名字年龄，也没有print函数，但他确实有这些东西，是继承下来的

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

我们的访问限定符有三种，public，protected和private

 我们简单记忆一下，基类的成员在派生类是不可见的，也就是不能用，这和private还不一样，private是类外面不能使用，类里面可以，而这里是类里面和类外面都不能用，就像有些人的家产不会全都给孩子继承，而是会捐献一部分，而捐献的这部分，就不属于子类

public和protected的成员，访问限定符取小的那一个，比如上面的protected继承public的，那成员就是protected的，private继承protected，成员就是private的，protected继承private的，成员就是private的

总结：

1. 基类 private 成员在派生类中无论以什么方式继承都是不可见的。这里的 不可见是指基类的私 有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面 都不能去访问它 。

2. 基类 private 成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected 。 可以看出保护成员限定符是因继承才出现的 。

3. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min( 成员在基类的访问限定符，继承方式 ) ， public > protected

> private 。

4. 使用关键字 class 时默认的继承方式是 private ，使用 struct 时默认的继承方式是 public ， 不过

最好显示的写出继承方式 。

5. 在实际运用中一般使用都是 public 继承，几乎很少使用 protetced/private 继承 ，也不提倡

使用 protetced/private 继承，因为 protetced/private 继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强

 

如果我们把这个public去掉，默认继承是私有继承

我们就不能用了

而当我们把class改成struct，默认继承就是公有的 

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

派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用 。这里有个形象的说法叫切片

或者切割。寓意把派生类中父类那部分切来赋值过去。

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

基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类

的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用 RTTI(Run-

Time Type Information) 的 dynamic_cast 来进行识别后进行安全转换。（ ps ：这个我们后

面再讲解，这里先了解一下）

举个例子

我们知道i赋值给d时是发生了类型转换的

 

这里也是一样，会发生类型转换，但是s=p是不允许的，父类是不能给子类的 

 

我们看这张图，左边是父类，右边是子类，子类的某些成员，父类是没有的，所以父类是不能给子类的

强制类型转换也不可以 ，语法是直接禁止这种的

子类给父类我们叫向上转换，父类给子类叫做向下转换

我们前面的 d = i 发生转换时，中间会产生临时变量，而这里是p = s 其实是赋值兼容（切割，切片），是天然的，中间不会产生临时变量，也就是认为子类对象是一个特殊的父类对象，会将子类对象里父类的部分切割出来拷贝给父类

怎么证明没有产生临时变量呢？

我们看这里是不允许的 ，因为中间产生了临时变量，临时变量具有常性，是权限的放大

不过我们加一个const就可以了

 

 而这里是不需要加const的 

如果是子类对象，就切割拷贝过去，如果是引用，变成切出来的那一部分的别名，这个规则非常重要，是我们后面内容的铺垫

我们把person的成员设为公有的

 此时我们通过调试就可以证明，p2就是切割出来的别名

总结一下，向上转换都是可以的，子类的对象可以给父类的对象/指针/引用

对于向下转换，对象是不允许的，但是指针和引用是可以的，比如父类的指针/引用指向子类的对象，指向子类对象的父类的那一部分，但向下转换会有很多问题，我们后面讲解

继承中的作用域

1. 在继承体系中基类和派生类都有独立的作用域。

2. 子类和父类中有同名成员， 子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏， 也叫重定义。 （在子类成员函数中，可以 使用 基类 :: 基类成员 显示访问 ）

3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。

4. 注意在实际中在 继承体系里 面最好 不要定义同名的成员 。

我们的person类和student类里都定义了num，但我们调用print函数后打印出的是999，也就是stdent中的，这里是就近原则 

我们想用父类的num，加上类域即可

这里就有一个概念，隐藏（重定义）：当子类和父类有同名成员时，子类成员会隐藏父类成员

隐藏不仅针对成员变量，还有成员函数 

 当然，想调用父类的也是可以的

大家想想这两个fun是隐藏还是重载？ 

答案是隐藏，因为重载有一个限定，是在同一个作用域里，而父子类域中，函数名相同，就构成隐藏

 我们可以看到，没有参数的fun报错了，这里编译器认为fun就是子类的fun，而我们没有传参，所以报错了

派生类的默认成员函数

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

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

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

3. 派生类的 operator= 必须要调用基类的 operator= 完成基类的复制。

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

5. 派生类对象初始化先调用基类构造再调派生类构造。

6. 派生类对象析构清理先调用派生类析构再调基类的析构。

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

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;
	}
protected:
	string _name; // 姓名
};

我们有这样一个父类

 然后我们用一个子类继承他，接着我们实现构造，按照传统的写法，我们会初始化name，但是这是错误的，编译器不允许显示的初始化父类成员

我们只能初始化自己的，而且，我们看到，这里我们是没有调用父类的构造的，但是结果是打印出了父类的构造和析构，因为C++规定子类必须调用父类的构造来初始化父类的成员

 调用是在初始化列表进行调用，而且父类不提供默认构造这里是会报错的

如果没有默认构造

 我们可以在子类里这样写，就像定义匿名对象一样

另外，初始化列表是Person先初始化，然后才初始化id，是和声明的顺序相关，继承的是放在自己的成员前面的

拷贝构造也是一样， 必须去调用父类的拷贝构造

但是有人会认为，父类的拷贝构造需要有一个父类的对象，该怎么办呢？

其实不用管，直接传就可以了 ，原因就是我们上面讲的，子类是可以给父类的，会进行切割

这里不写会去掉默认构造，所以s2的name和s1是不一样的，s2的是peter

没有默认构造会报错

所以即使我们提供了默认构造不写也是不行的，不符合拷贝，所以我们要去显示的调用拷贝构造

 赋值的话我们直接这样写就可以了 

不过我们运行的话其实是出问题了
 这里发生了栈溢出

 这里是有隐藏的，本来是想调用父类的，但是调不到

所以我们指定一下

下面我们再看析构

这里在报错，没有合适的默认构造

 

我们这里需要指定，为什么呢？

由于后面多态的原因，析构函数的函数名被特殊处理了，被统一处理成了destructor，所以就构成了隐藏，这个我们后面会讲

可是当我们指定以后，3个对象却调用了6次析构

而当我们屏蔽之后却又正常了

前面的需要我们手动调用，而析构函数会自动调用

如果我们把子类对象分为父部分和子部分， 构造时会先构造父，然后构造子，但是析构时会先析构子，然后析构父

我们加一个指针，然后显示调用，我们可以发现，显示调用是无法保证先析构子再析构父的

我们的构造函数顺序随便写都可以，因为这里是根据初始化列表走，一定可以保证先父后子

 所以子类构造函数完成就会自动调用父类析构，这样就可以保证先子后父

这里如果大家调试的话，可以发现当我们运行代码时，进入子类的析构函数，然后在子类析构结尾时我们f11会进入父类析构

这点比较特殊，为什么要先子后父？因为子类里可能会用到父类的成员，但是父类里是不会用子类成员的

举个例子，我们在父类里加一个string*

 

然后我们在析构之后还想再打印一下，这里就出问题了 

继承与友元

这里简单来说就是一句话，友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员

比如这里display是父类的友元，而子类的友元调用会报错 

要想通过，需要把display也设为子类成员

继承与静态成员

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()
{
	Person p;
	Student s;
	cout << &p._name << endl;
	cout << &s._name << endl;

	cout << &p._count << endl;
	cout << &s._count << endl;

	cout << &Person::_count << endl;
	cout << &Student::_count << endl;
}

 静态成员属于父类和派生类，在派生类中不会单独拷贝一份，继承的是使用权

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

类，都只有一个 static 成员实例 。

如果我们想要统计person和他的派生类创建了多少对象，我们只需定义一个静态成员，然后在父类的构造函数里++即可

 因为子类进行初始化时会调用父类的构造函数

复杂的菱形继承及菱形虚拟继承

C++的继承是一个大坑，因为C++的继承是可以多继承的

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

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

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

我们先来聊聊为什么需要多继承，比如现实里有些生物即有动物的特征，又有植物特征，或者我们在工作中的兼职等等都是多继承的场景

我们来看菱形继承的问题，我们看上面的图片

对于assistant的结构就是这样的， 他有两个name，当然有人会认为两个名字没什么，作为老师和作为学生时名字不一样，但是person里还有身份证号码，住址等等，这些是不可能有多个的

我们给person加了年龄，这样就报错了，他不知道这个年龄属于哪一个 ，我们把这个问题叫做数据冗余二义性，数据冗余是浪费空间，二义性是不明确

 二义性我们可以这样解决，但是这样也不好，是违背常理的

为了解决多继承的问题，C++又引入了虚拟继承，后来坑更大了

虚拟继承是在中间腰部的位置加一个关键字virtual，他的底层非常复杂 

 有了虚拟继承，这里的问题就解决了，此时assistant就只有一个age了，如果我们进入调试的话，是可以看到年龄更新的

就像这里，看着有三个age，其实他只有一个

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

class A
{
public:
	int _a;
};
// class B : public A
class B : virtual public A
{
public:
	int _b;
};
// class C : public A
class C : virtual public A
{
public:
	int _c;
};
class D : public B, public C
{
public:
	int _d;
};

画出来就是这样的

我们先看菱形继承，即先把上面的虚拟继承去掉

 

 我们来看内存窗口

我们再看菱形虚拟继承，也就是上面的代码

 我们发现，结构发生了非常大的变化，不管用谁去访问A都只有一个A，是把A单独拿出来了，即没有放到B里也没有放到C里，不过他多了一点东西，就像B里的dc 7b e9 00这一行，C里面也有，他看起来像一个指针，这两个东西

 这两个地址指向的是0，但是下一个位置是有效值，第一个20（16进制），第二个是12

 

 20其实是从0x00F9FA98开始，到0X00F9FAAC的偏移量，二者相减就是20，12是同理，是0x00F9FAA0开始的

为什么不直接在这些地址的位置存20和12呢？因为还要存其他值，存在对象里会让对象变大

 如果我们还有别的对象，比如有一个d2，此时我们只需让d2也指向20和12即可，这样节省空间

20和12在的地方也叫做虚机表，意思是存找基类偏移量的表

偏移量的使用场景在切割，比如 B* pb = &d; pb->_a = 1;

  而且B使用虚拟继承后和D的结构也是相似的，这个8是到a的距离

 这是我们的一个使用场景

 

 我们看到，这两个是差不多的，切片的时候不需要单独处理，都是先取偏移量，然后计算_a在对象中的地址，再访问

 下面我们再计算一下这些结构的大小

首先是不使用虚拟继承时D的大小，是20，我们计算一下这是为什么

 B和C都是8字节，再加上D本身的4个字节，就是20字节

下面再看看虚拟继承

变成了24

 

 B和C都还是8，D本身的4，加上他们父类的int是4，加起来就是24

菱形虚拟继承不仅解决了二义性的问题，还解决了数据冗余的问题，只是这个解决付出了代价，花费了两个指针，节省了4字节，上面这个情况我们计算下来是亏损的，当A变大时就是赚的

比如我们把A设为128时

 

这是不使用虚拟继承的结果

 

这是使用虚拟继承的结果 

差距还是非常明显的（还有一些对齐的问题）

不过菱形继承总的来说还是非常麻烦，后面再加上多态会变得非常麻烦，所以我们不要使用菱形继承，没有菱形继承就不会有菱形虚拟继承，我们可以使用多继承，但不要使用菱形继承

继承的总结和反思

1. 很多人说 C++ 语法复杂，其实多继承就是一个体现。有了多继承 ，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。

2. 多继承可以认为是 C++ 的缺陷之一，很多后来的 OO 语言（面向对象）都没有多继承，如 Java 。

3. 继承和组合

public 继承是一种 is-a 的关系。也就是说每个派生类对象都是一个基类对象。

组合是一种 has-a 的关系。假设 B 组合了 A ，每个 B 对象中都有一个 A 对象。

优先使用对象组合，而不是类继承 。

继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称

为白箱复用 (white-box reuse) 。术语 “ 白箱 ” 是相对可视性而言：在继承方式中，基类的

内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很

大的影响。派生类和基类间的依赖关系很强，耦合度高。

对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象

来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复

用 (black-box reuse) ，因为对象的内部细节是不可见的。对象只以 “ 黑箱 ” 的形式出现。

组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被

封装。

实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有

些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用

继承，可以用组合，就用组合。

 

继承和组合都是一种复用 

如果有一个场景既可以用组合又可以用继承，那就优先组合，不过我们后面的多态是需要使用继承的

以上即为本期全部内容，希望大家可以有所收获

如有错误，还请指正。