?专栏导读

?作者简介：花想云，在读本科生一枚，致力于 C/C++、Linux 学习。

?本文收录于 C++系列，本专栏主要内容为 C++ 初阶、C++ 进阶、STL 详解等，专为大学生打造全套 C++ 学习教程，持续更新！

?相关专栏推荐：C语言初阶系列 、C语言进阶系列 、数据结构与算法、Linux从入门到精通

?文章导读

本章我们将学习C++三大特性之一的继承。继承作为C++最重要的特性之一，意味着其难度也是相当高的。且继承同样为C++另一大特性——多态的重要基石，非常值得我们深入学习~

在C++中，既然将之取名为继承，自然是因为与现实中的继承有某些相似的地方。

• 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，从而产生一个新的类，称之派生类。

继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。

?继承的定义方式

// 基类（父类）
class Person
{
public:
	void test()
	{
		cout << "Person" << endl;
	}
protected:
	string _name; // 名字
};

// 派生类（子类）
class Student : public Person
{
private:
	int _stuid; // 学号
};

·

如上述代码所示，

• 我们称之为Student类继承了Person类；
• Person类称作基类或父类；
• Student类称作派生类或者子类；
• public为一种继承方式；

当子类继承父类之后，父类Person的成员（成员函数+成员变量）都会变成子类的一部分。例如，当我们创建好一个子类对象，并查看对象的成员：

当然我们还可以调用父类Person中的成员函数：

?继承方式与访问限定符

在学习类时，我们曾经认识了 3 个访问限定符：

• public —— 公有访问
• protected —— 保护访问
• private —— 私有访问

在继承中，这三个关键字同样可以表示 3 种继承方式：

• public —— 公有继承
• protected —— 保护继承
• private —— 私有继承

虽然这两组概念中，这 3 个关键字都是相同的，但是所表达的意义却不同。继承方式与访问限定符(指基类中）共同决定了子类中成员的访问权限的上限。我们可以用一张表来展示继承方式与访问限定符的不同组合：

基类成员/继承方式	public继承	protected继承	private继承
基类的public成员	派生类的public成员	派生类的protected成员	派生类的private成员
基类的protected成员	派生类的protected成员	派生类的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继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

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

在之前的学习中，我们知道一个类型的对象赋值给另一个类型相似的对象时，会发生隐式类型转换并生成一个中间临时变量。例如：

	double d = 1.1;
	int i = d; // 隐式类型转换

在继承中，子类对象也可以赋值给一个父类对象，但并不会发生类型转换。有如下注意事项：

• 派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。

class Person
{
public:
	void test()
	{
		cout << "Person" << endl;
	}
protected:
	string _name;
};

class Student : public Person
{
public:
	void test()
	{}
private:
	int _stuid;
};
int main()
{
	Student s;
	// 1.子类对象可以赋值给父类对象/指针/引用
	Person p = s;
	Person* p_str = &s;
	Person& p_ref = s;
	return 0;
}

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

	//2.基类对象不能赋值给派生类对象
	//s = p; 

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

	// 3.基类的指针可以通过强制类型转换赋值给派生类的指针
	p_str = &s;
	Student* s_ptr1 = (Student*)p_str; // 正确

	p_str = &p;
	Student* s_ptr1 = (Student*)p_str; // 有越界访问的危险

?继承中的作用域

在继承体系中基类和派生类都有独立的作用域。我们需要注意以下事项：

• 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义；

class Person
{
public:
	void print()
	{
		cout << "Person" << endl;
	}
protected:
	string _name = "person";
};

class Student : public Person
{
public:
	void test()
	{
		cout << _name << endl;
	}
private:
	string _name = "peter";
	int _stuid;
};

int main()
{
	Student s;
	s.test();
	return 0;
}

• 在子类成员函数中，可以使用 基类::基类成员 显示访问；

class Person
{
public:
	void print()
	{
		cout << "Person" << endl;
	}
protected:
	string _name = "person";
};

class Student : public Person
{
public:
	void test()
	{
		cout << Person::_name << endl;
	}
private:
	string _name = "peter";
	int _stuid;
};

int main()
{
	Student s;
	s.test();
	return 0;
}

• 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏（注意区别隐藏与函数重载，函数重载只发生在同一作用域）；

class Person
{
public:
	void print()
	{
		cout << "In Person" << endl;
	}
protected:
	string _name = "person";
};

class Student : public Person
{
public:
	void print()
	{
		cout << "In Student" << endl;
	}
private:
	string _name = "peter";
	int _stuid;
};
int main()
{
	Student s;
	s.print();
	return 0;
}

• 注意在实际中在继承体系里面最好不要定义同名的成员（易混淆）。

?派生类的默认成员函数

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

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

class Person
{
public:
	Person(const string& name)
		:_name(name)
	{
		cout << "Person(const string& name)" << endl;
	}
	/*Person(const Person& p)
		:_name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}*/
protected:
	string _name;
};

class Student : public Person
{
public:
	Student(const string name,int id)
		:Person(name) // 显示调用构造函数
		, _stuid(id)
	{
		cout << "Student(const string name,int id)" << endl;
	}
	/*Student(const Student& s)
		:Person(s)
		, _stuid(s._stuid)
	{
		cout << "Student(const Student& s)" << endl;
	}*/

private:
	int _stuid;
};
int main()
{
	Student s("peter",12345);
	return 0;
}

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

class Person
{
public:
	// ...省略之前代码
	Person(const Person& p)
		:_name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}
protected:
	string _name;
};

class Student : public Person
{
public:
	// ...省略之前代码
	Student(const Student& s)
		:Person(s)
		, _stuid(s._stuid)
	{
		cout << "Student(const Student& s)" << endl;
	}

private:
	int _stuid;
};
int main()
{
	Student s1("peter",12345);
	Student s2(s1);
	return 0;
}

• 派生类的operator=必须要调用基类的operator=完成基类的复制；

class Person
{
public:
	// ...省略之前代码
	Person& operator=(const Person& p)
	{
		cout << "Person operator=(const Person& p)" << endl;
		if (this != &p)
			_name = p._name;

		return *this;
	}
protected:
	string _name;
};

class Student : public Person
{
public:
	// ...省略之前代码
	Student& operator=(const Student& s)
	{
		if (this != &s)
		{
			Person::operator=(s); // 调用基类的赋值重载
			_stuid = s._stuid;
		}
		cout << "Student& operator=(const Student& s)" << endl;
		return *this;
	}

private:
	int _stuid;
};
int main()
{
	Student s1("peter",12345);
	Student s2("xxxx",0);
	s2= s1;
	return 0;
}

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

class Person
{
public:
	// ...省略之前代码
protected:
	string _name;
};

class Student : public Person
{
public:
	// ...省略之前代码
	~Student()
	{
		cout << "~Student()" << endl;
	}
private:
	int _stuid;
};
int main()
{
	Student s1("peter",12345);
	return 0;
}

• 派生类对象初始化先调用基类构造再调派生类构造；

• 派生类对象析构清理先调用派生类析构再调基类的析构；

?继承与友元

• 友元关系是不能继承的，基类友元不能访问子类私有和保护成员（父亲的朋友不一定是我的朋友）。

?继承与静态成员

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

// 统计一个创建了多少个子类对象
class Person
{
public:
	static int count;
protected:
	string _name;
};

int Person::count = 0;

class Student : public Person
{
public:
	Student()
	{
		count++;
	}
private:
	int _stuid;
};
int main()
{
	Student s1;
	Student s2;
	Student s3;
	Student s4;
	Student s5;

	cout << Person::count << endl;
	return 0;
}

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

一个类可以被多个类继承（有多个儿子），同样的，一个类也可以继承多个类（有多个父亲）。

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

	class Person
	{};
	class Student : public Person
	{};

• 多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承，多继承可以类比单继承，原理类似；

	class Teacher
	{};
	class Student
	{};
	class Assistant:public Student,public Teacher
	{};

• 菱形继承：菱形继承是多继承的一种特殊情况。当派生类继承的几个不同的基类拥有一个共同的基类；

	class Person
	{};
	class Teacher :public Person
	{};
	class Student :public Person
	{};
	class Assistant:public Student,public Teacher
	{};

?菱形继承所引发的问题

以下是一种菱形继承：

class Person
{
public:
	string _name;
};
class Teacher :public Person
{
protected:
	int _id; // 职工编号
};
class Student :public Person
{
protected:
	int _num; //学号
};
class Assistant :public Student, public Teacher
{
protected:
	string _majorCourse; // 主修课程
};

?二义性

当我们定义了一个Assistant类型的对象，该对象的成员中包含两个_name，分别是从Student和Teacher所继承。

int main()
{
	Assistant a;
	return 0;
}

当我们想要访问_name成员时，就会出现二义性，编译器并不知道我们要访问哪一个_name成员。

	cout << a._name << endl;

当然，我们可以通过指定类域来访问：

int main()
{
	Assistant a;
	cout << a.Student::_name << endl;
	cout << a.Teacher::_name << endl;
	return 0;
}

?数据冗余

数据冗余是指，当我们创建一个对象时，它的某个属性（某个成员）只有一个值即可。但是内存中却实实在在的存储了两份数据，其中有一份数据必然是多余的。就如同，现实中一个人可能在不同的环境中有不同的称呼，但是，身份证上只有一个名字就够了。

?虚拟继承解决二义性与数据冗余

C++祖师爷为我们提供了解决菱形继承问题的当法——虚拟继承。在继承方式前面加上关键字virtual，如下：

class Person
{
public:
	string _name;
};
class Teacher :virtual public Person
{
protected:
	int _id; // 职工编号
};
class Student :virtual public Person
{
protected:
	int _num; //学号
};
class Assistant :public Student, public Teacher
{
protected:
	string _majorCourse; // 主修课程
};

int main()
{
	Assistant a;
	a._name = "peter";
	return 0;
}

注意此时监视窗口虽然依旧看到存在两个_name，但其实在内存中只存在一份数据，监视窗口是编译器修饰过的，为了方便我们观察。

?原理

?菱形继承下的对象模型

为了便于观察，我们再来看一组菱形继承的例子：

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;
}

打开内存窗口，输入对象d的地址，我们可以粗略的看到对象模型：

注意，此时_a的数据有两份，一份属于B类，一份属于C类。再来看看加了虚拟继承之后的效果；

?菱形虚拟继承

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

打开内存窗口，输入对象d的地址，我们可以粗略的看到对象模型：

通过观察我们可以发现虚拟继承与非虚拟继承的几个不同点：

• 虚拟继承后，_a只会保留一份，占用一份内存空间；
• B和C中好像各自多了一个指针一样的数字；

其实，B和C中存放的奇怪数字就是两个指针，我们叫它们——虚基表指针。这两个指针分别指向两张表，称之为——虚基表。

我们继续通过内存窗口观察一下这两个表中分别存了什么东西吧。

如图所示，两张虚基表中分别存了两个数字——20，12。那么这两个数字有何含义呢？它们其实是偏移量——是_a的位置相对于B和C起始地址的偏移量。

下图是上面的Person关系菱形虚拟继承的原理解释：

?继承的总结和反思

• 由于菱形继承过于复杂，且使用场景不多，所以在实际应用中，应当尽量减少使用多继承；
• 多继承可以认为是C++的缺陷之一，很多后来的OO语言都没有多继承，如Java；
• 继承与组合比较：

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

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

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

  • 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。

  • 对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。

  • 实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合。

本章的内容就到这里了，觉得对你有帮助的话就支持一下博主吧~