C++中的继承

class Person
{
protected:
	string _name; // 姓名
	string _sex;  // 性别
	int _age; // 年龄
};
class Student : public Person
{
public:
	int _No; // 学号
};
void Test()
{
	Student stu;
	// 1.子类对象可以赋值给父类对象/指针/引用
	Person peo = stu;
	Person* pp = &stu;
	Person& rp = stu;

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

	// 3.基类的指针可以通过强制类型转换赋值给派生类的指针
	Student * ps1 = (Student*)pp; // 这种情况转换时可以的。
	ps1->_No = 10;

	pp = &peo;
	Student* ps2 = (Student*)pp; // 这种情况转换时虽然可以，但是会存在越界访问的问题
	ps2->_No = 10;
}

3. 继承中的作用域

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

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

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

实际中在继承体系里面最好不要定义同名的成员（这里特指成员变量；同名成员函数满足一定的条件后可构成多态，有大用！）

如下代码示例：

class People		//基类
{
public:
	//函数隐藏
	void Hide()
	{
		cout << "People::_hide = " << _hide << endl << "void People::Hide()" << endl;
	}

protected:
	int _hide = 1;//同名成员变量隐藏
};


class Student : public People	//派生类
{
public:
	void Hide(int x = 10)
	{
		cout << "Student::_hide = " << _hide << endl;
        cout << "Student::People::_hide = " << People::_hide << endl;
		cout << "void Student::Hide(int x = 10)" << endl;
	}

protected:
	int _hide = 10;//同名成员变量隐藏
};

int main()
{
	Student s1;
	s1.Hide();
	return 0;
}

输出结果：

注意和函数重载区分开，满足函数重载的条件为（缺一不可）：1：在同一作用域中；2：函数名相同；3：参数不同（个数/类型）。

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

在小编的另一篇分享《类和对象（中）—— 类的6个（C++98）默认成员函数》中，已经详细介绍了类的默认成员函数，此处不再赘述。

这里的重点在于：明确继承体系下，基类和派生类的这些函数调用规则。

以构造函数为例，成员变量的定义并初始化一定是走初始化列表，顺序由声明顺序决定；派生类 = 基类（1） + 扩展（2），基类的声明一定在派生类之前，所以派生类实例化的对象走派生类的构造函数中的初始化列表时，先调用所继承的基类的构造函数，再初始化其它的扩展成员。

拷贝构造，赋值重载等默认函数的调用顺序也是：先父后子。

但是，析构函数是个例外，属于：先子后父。因为：派生类的扩展成员的资源的释放工作可能需要父类成员的数据支持。比如：派生类对象在程序运行过程中产生的一些计算数据要根据基类的成员判断是否要保存，要存到哪里等，此时基类成员的资源释放就一定要放到后面！

5. 继承与友元，静态成员

重点就两句话：

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

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

（如果对友元和静态成员的认识存疑，可以点击前往小编的另一篇分享《类和对象（下）—— 语法细节补充》查看）

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

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

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

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

接下来，小编将以下面这段代码演示菱形继承存在的问题和如何解决：

class A
{
public:
	int _a = 1;
};

//class B : public A//单继承
class B : public A
{
public:
	int _b = 2;
};

//class C : public A//单继承
class C : public A
{
public:
	int _c = 3;
};

class D : public B, public C//菱形继承
{
public:
	int _d = 4;
};

int main()
{
	D test;
	return 0;
}

由上代码，看图：

可以发现：问题1：一个对象中出现了两份A，数据冗余，造成资源浪费。

问题2：test._a会有二义性，无法明确知道访问的是哪一个。

虽然指定类域，如test.B::_a和test.C::_a可以解决二义性，但无法解决数据冗余。

为了同时解决这两个问题，C++引入了：虚拟继承 —— virtual

使用方法：在同时直接继承了类A的 B和C 的继承方式前加 virtual

class B : virtual public A;

class C : virtual public A;

原理如下图所示：

可能你会疑惑为什么D中B和C部分要去找属于自己的A？

还记得前面的赋值转换吗：D d;

B b = d;

C c = d;

d要去找出B/C成员中的A才能赋值过去。

7. 继承的总结和反思

有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，特别是菱形继承，否则在复杂度及性能上极大概率都有问题。

多继承可以认为是C++的缺陷之一，很多后来的语言都没有多继承，如Java。

这里还需要特别区分一下：继承和组合

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

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

原则：优先使用对象组合，而不是继承。

【《极限编程》(Extreme programming)的指导原则之一是“只要能用，就做最简单的”。一个似乎需要继承的设计常常能够戏剧性地使用组合来代替而大简化，从而使其更加灵活。因此，在考虑一个设计时，问问自己：“使用组合是不是更简单？这里真的需要继承吗？它能带来什么好处？”

继承和组合的比较:

面向对象系统中功能复用的两种最常用技术是类继承和对象组合(object composition)。正如我们已解释过的，类继承允许你根据其他类的实现来定义一个类的实现。这种通过生成子类的复用通常被称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，父类的内部细节对子类可见。

对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。

继承和组合各有优缺点。类继承是在编译时刻静态定义的，且可直接使用，因为程序设计语言直接支持类继承。类继承可以较方便地改变被复用的实现。当一个子类重定义一些而不是全部操作时，它也能影响它所继承的操作，只要在这些操作中调用了被重定义的操作。

但是类继承也有一些不足之处。首先，因为继承在编译时刻就定义了，所以无法在运行时刻改变从父类继承的实现。更糟的是，父类通常至少定义了部分子类的具体表示。因为继承对子类揭示了其父类的实现细节，所以继承常被认为“破坏了封装性” 。子类中的实现与它的父类有如此紧密的依赖关系，以至于父类实现中的任何变化必然会导致子类发生变化。当你需要复用子类时，实现上的依赖性就会产生一些问题。如果继承下来的实现不适合解决新的问题，则父类必须重写或被其他更适合的类替换。这种依赖关系限制了灵活性并最终限制了复用性。一个可用的解决方法就是只继承抽象类，因为抽象类通常提供较少的实现。

对象组合是通过获得对其他对象的引用而在运行时刻动态定义的。组合要求对象遵守彼此的接口约定，进而要求更仔细地定义接口，而这些接口并不妨碍你将一个对象和其他对象一起使用。这还会产生良好的结果：因为对象只能通过接口访问，所以我们并不破坏封装性；只要类型一致，运行时刻还可以用一个对象来替代另一个对象；更进一步，因为对象的实现是基于接口写的，所以实现上存在较少的依赖关系。

对象组合对系统设计还有另一个作用，即优先使用对象组合有助于你保持每个类被封装，并被集中在单个任务上。这样类和类继承层次会保持较小规模，并且不太可能增长为不可控制的庞然大物。另一方面，基于对象组合的设计会有更多的对象 (而有较少的类)，且系统的行为将依赖于对象间的关系而不是被定义在某个类中。

这导出了我们的面向对象设计的第二个原则：优先使用对象组合，而不是类继承。】【此处为引用；源出处：残雪余香】

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

最后，如果需要完整的代码示例练习或者本篇知识点快览总结，可点击链接前往我的Gitee仓库自取： https://gitee.com/a-clear-meaning/cpp/blob/master/%E9%87%8D%E7%82%B9%E7%9F%A5%E8%AF%86%E6%80%BB%E7%BB%93/%E7%BB%A7%E6%89%BF/test.cpphttps://gitee.com/a-clear-meaning/cpp/blob/master/%E9%87%8D%E7%82%B9%E7%9F%A5%E8%AF%86%E6%80%BB%E7%BB%93/%E7%BB%A7%E6%89%BF/test.cpp