【C++】：面向对象三大特性之继承

1.继承的概念及定义

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

class Person
{
public:
	void Print()
	{
		cout << "name " << name << endl;
		cout << "age " << age << endl;
	}
protected:
	string name = "zhangsan";
	int age = 20;
};
//1.Stu和Tearch继承了Person
//2.成员变量name\age和成员函数都变为Person的一部分
//3.Stu和Tearch复用了Person代码
class Stu :public Person
{
protected:
	int stuid;//学号
};
class Tearch : public Person
{
protected:
	int jobid;//工号
};

我们可以通过监视窗口看到现象：

继承的定义格式如下：

class Stu :public Person
{
	public:
		int id;
} 

在上边的例子中，Stu为派生类，Person为基类，然后冒号后边的public代表继承方式。C++中存在三种继承方式：

• public继承
• protected继承
• private继承

基类的成员随着继承方式的不同在派生类当中的访问限定符是存在变化的：

类成员\继承方式	public继承	protected继承	private继承
基类的public成员	派生类public	派生类 protected	派生类private
基类的protected成员	派生类protected	派生类 protected	派生类private
基类的private成员	派生类 private	派生类 private	派生类private

• 基类private成员在派生类中无论以什么方式继承都是不可见的。不可见是指基类的私有成员可以被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
• 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
• 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。

2.基类和派生类对象赋值相互转化

• 派生类对象可以直接赋值给基类的指针、引用和对象。这种做法叫切片或者切割，意思是将继承基类的那部分切割出来赋值给父类。但是基类的对象是不能赋值给子类的对象。
• 基类的指针可以通过强制类型转化赋值给派生类的指针。但是当基类的指针指向派生类的对象才是安全的。

总结：

• 派生类对象可以赋值给基类的对象、引用、指针 * 基类对象不能赋值给派生类的对象
• 基类的指针可以赋值给派生类的指针(当这个指针指向派生类对象时时安全的)
• 基类的指针(指向基类的对象)赋值给派生类指针时，会存在越界访问的问题

3.继承时的作用域

• 父类和子类有独立的作用域
• 子类中如果存在和父类同名的成员，则在子类中将隐藏父类中的该同名成员，也叫做重定义。在子类中，若想访问父类的同名成员，可以使用基类名::基类成员访问
• 如果是成员函数，只要函数名相同，则就会构成隐藏
• 区别隐藏和重载：重载指的是在同一个作用域中，相同的名字不同的函数参数构成重载。隐藏是指在父类和子类两个不同的作用域中，子类中对父类的同名成员构成隐藏

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

关于C++类中的6大默认成员函数：https://blog.csdn.net/hansionz/article/details/83411374

• 派生类的构造函数必须调用基类的构造函数来初始化基类的成员。如果基类中没有默认的构造函数，则必须在派生类的初始化列表中显式的调用基类的构造
• 派生类的拷贝构造必须先调用基类的拷贝构造来完成基类的拷贝初始化
• 派生类的operator=必须要调用基类的operator=完成基类的赋值
• 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序

总结：

• 派生类对象在初始化时，先调用基类构造，在调用派生类构造
• 派生类对象在析构时，先调用派生类的析构，在调用基类的析构

实现一个不能被继承的类：

 class NonInherit1
{
public:
  static NonInherit1 GetInstace()
  {
    return NonInherit1();
  }
  //c++98 构造私有化让一个类不被继承
private:
  NonInherit1()
  {}
};
//c++11给出了新的关键字final让一个类不被继承
class NonInherit2 final
{};

5.继承的友元和静态成员

友元：
关于友元总结在我的另一篇博客：https://blog.csdn.net/hansionz/article/details/83478079

友元关系不能被继承，说明基类的友元函数或者友元类不能访问派生类的私有成员。

静态成员：
关于静态成员总结在我的另一篇博客：https://blog.csdn.net/hansionz/article/details/83478079

基类如果定义了一个静态成员，则在整个继承体系中只有一个静态成员，无论派生出多少个子类。

统计一个基类的派生类存在多少个对象：

class A
{
public:
  A()
  {
    ++count;
  }
public:
  static int count;
protected:
  int name;
};
//静态成员在类外定义
int A::count = 0;

class B : public A
{};
class C : public A
{};

int main()
{
  B b;
  C c;
  cout << A::count << endl;//2
  return 0;
}

6.菱形继承和菱形虚拟继承

C++中的几种继承：

• 单继承：一个子类只有一个直接父类
• 多继承：一个子类存在两个或两个以上的直接父类
• 菱形继承：菱形继承时多继承的一种特殊情况。具体看下边这幅继承关系图。

• 

菱形继承存在的问题：从上面的基础模型可以看出在Ass类中会存在两份Person的数据，所以菱形继承会存在数据的冗余和二义性。

class Person
{
public:
    string name;
};

class Stu:public Person
{
protected:
  int num;//学号
};

class Tearch:public Person 
{
protected:
  int id;//工号
};

class Ass :public Stu, public Tearch
{
protected:
  string major;
};

int main()
{
  Ass a;
  //这么访问会存在数据二义性
  //a.name = "zhangsan";
  //这么做可以消除二义性，但是依然存在数据冗余
  a.Stu::name = "zhangsan";
  a.Tearch::name = "lisi";

  return 0;
}

虚拟菱形继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在Stu和Tearch的继承Person时使用虚拟菱形继承时，可以解决数据的二义性和冗余问题。

class Person
{
public:
    string name;
};

class Stu:virtual public Person
{
protected:
  int num;//学号
};

class Tearch:virtual public Person 
{
protected:
  int id;//工号
};

class Ass :public Stu, public Tearch
{
protected:
  string major;
};

int main()
{
  Ass a;
  //可以很好的解决二义性和数据冗余问题
  a.name = "zhangsan";

  return 0;
}

虚拟继承原理：以一个简单的菱形继承模型分析。

• 当没有使用虚拟继承时

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，存在二义性和数据冗余问题。

• 当使用虚拟菱形继承时

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放到的了对象组成的最下面，这个A同时属于B和C，那么B和C如何去找到公共的A呢。这里是通过了B和C的两个指针，指向的一张表，这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的A，这就是虚拟继承的原理。

为什么B和C一定要找到自己的a呢？

 //当下面的赋值发生时，d要去找出B/C成员中的a才能赋值过去,切片    
 D d;    
 B b = d;    
 C c = d;

注：C++的语法太过复杂可以体现在多继承上，多继承可以算上是C++的缺陷之1，它们的底层实现很复杂，一般不建议设计出多继承。

7.组合和继承

• 公有继承时一种is-a关系，它表示派生类对象都是一个基类对象。而组合是一种has-a的关系，它表示假设A组合了B，那么每一个A对象中都包含一个B对象。例如：车和宝马构成is-a关系，而车和轮胎构成has-a关系。
• 继承允许根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse)。在继承方式中，基类的内部细节对子类可见 。继承一定程度破坏了基类的封装，基类的改变，对派生类类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
• 对象组合是类继承之外的另一种代码复用选择。新的更复杂的功能可以通过组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse)， 因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。 组合类之间没有很强的依赖关系， 耦合度低。优先使用对象组合有助于你保持每个类被封装。
• 实际中多去用组合，因为组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。
• 优先使用组合，耦合度低，内聚高。