[ C++ ] 继承

问题引入：

面向对象编程的主要目的之一是提供可重用的代码，C++提供了一个方法来扩展和修改类。这种方法叫做类继承。它能够从已有的类派生出新的类，而派生类继承了原有类(称为基类)的特征，包括方法。

1.继承的概念和定义

1.1继承的概念

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保

持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象

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

承是类设计层次的复用。

一个简单的基类：

从一个类派生出另一个类时，原始类称为基类，继承类称为派生类。为说明继承，首先需要一个基类。Person类中有_name，_age成员变量，有Print()成员方法。接下来我们将派生一个Student学生类

//父类、基类
class Person
{
public:
  void Print(){
    cout << "name :" << _name << endl;
    cout << "age :" << _age << endl;
  }

//private:
//protected:
  string _name = "Peter";
  int _age = 18; 
};

[ C++ ] 继承

派生一个类：

派生类的声明方式，首先将Student类声明为从Person类派生而来：

class Student : public

[ C++ ] 继承

冒号指出Student类的基类是Person类。public表示Person是一个公有基类，这被称为公有派生。派生类对象包含基类对象。使用公有派生，基类的公共成员将成为派生类的公有成员；基类的私有部分也将成为派生类的一部分，但只能通过基类的公有和保护方法访问。换句话说，Student类定义的对象s，可以使用Person类中的公有方法。

那么Student对象具有以下特征：

1.派生类对象存储了基类的数据成员（派生类继承了基类的实现）。

2.派生类对象可以使用基类的方法（派生类继承了基类的接口）。

派生类需要添加什么呢？

1. 派生类需要自己的构造函数。

2.派生类可以根据需要添加额外的数据成员和成员函数。

那么我们现在写一个Student类：

class Student : public Person
{
public:
  void func(){
    Print();
  }
protected:
  int _stuid;//学号

[ C++ ] 继承

我们可以看到Student类继承了Person类，并且是公有继承，并且Student类拥有自己额外的成员变量以及成员函数。

[ C++ ] 继承

1.2 继承定义

1.2.1定义格式

上文我们所提到的，Person类是基类(父类)，Stundent是派生类(子类)。继承方式是公有继承。

[ C++ ] 继承

1.2.2 继承关系和访问限定符

继承方式不仅有我们刚提到的公有继承(public)，还有保护继承(protected)以及私有继承(private)，在类中，访问限定符可以选择性的将其接口提供给外部的用户使用。因此类内有3中方式，类继承有3中方式，这样就组成了9中的访问关系。

[ C++ ] 继承

1.2.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继承下来的成员都只能在派生类的类里

面使用，实际中扩展维护性不强。

代码示例：

class Person
{
public:
  void Print(){
    cout << "name:" << _name << endl;
    cout << "age:" << _age << endl;
    cout << "ID:" << _ID << endl;
  }
public:
  string _name = "张三";

protected:
  int _age = 18;

private:
  int _ID = 1;
};

class Student : public

[ C++ ] 继承

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

派生类对象可以赋值类基类对象/基类的指针/基类的引用。这里有个形象的说法叫做切片或者切割。寓意把派生类中父类那部分切来赋值过去。
基类对象不能赋值给派生类对象。
基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。

[ C++ ] 继承

class Person
{

//protected:
public:
  string _name; // 姓名
  string _sex;  // 性别
  int  _age;   // 年龄
};

class Student : public Person
{
public:
  int _No; // 学号

[ C++ ] 继承

1.子类对象给父类对象/指针/引用 -- 语法天然支持，没有类型转换

//对象
  Person& rp = s;    //引用
  Person* ptrp = &s;  //指针

[ C++ ] 继承

2.基类对象不能赋值给派生类对象

[ C++ ] 继承

3. 基类的指针可以通过强制类型转换赋值给派生类的指针

//这种情况下转换是可以的
  ps1->_No = 10;

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

[ C++ ] 继承

3. 继承中的作用域

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

1. 成员变量导致隐藏关系

Student的_num和Person的_num构成隐藏关系，可以看出这样的代码虽然能跑，但是非常容易混淆，因此尽量避免重名。

class Person
{
protected:
  string _name = "张三"; // 姓名
  int _num = 111;      // 身份证号
};

class Student : public Person
{
public:
  void Print(){
    cout << " 姓名:" << _name << endl;
    cout << " 学号:" << _num << endl;//会使用自己的成员变量 999
    cout << " 身份证号:" << Person::_num << endl; //要指定作用域
  }
protected:
  int _num = 999; // 学号
};
int main(){
  Student s;
  s.Print();
  return 0;
}

[ C++ ] 继承

2. 成员方法导致隐藏关系

这段代码中b的fun()和A的fun()构成隐藏关系，b的fun()隐藏了A的fun()，若要使用A的fun()显示指定作用域即可访问到A的fun()。

class A
{
public:
  void fun(){
    cout << "A::func()" << endl;
  }
};
class B : public A
{
public:
  void fun(){
    cout << "B::func()"<< endl;
  }
};

int main(){
  B b;
  b.fun();//b的fun()隐藏了A的fun()
  b.A::fun();//指定作用域即可访问到A的func()
  return 0;
};

[ C++ ] 继承

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

我们在学习类与对象第一节时就知道了类内会默认生成6个成员函数，那么在派生类中，这几个成员函数是如何生成的呢？

派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
派生类的operator=必须要调用基类的operator=完成基类的复制。
派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
派生类对象初始化先调用基类构造再调派生类构造。
派生类对象析构清理先调用派生类析构再调基类的析构。
因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同。那么编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加 virtual的情况下，子类析构函数和父类析构函数构成隐藏关系。

[ C++ ] 继承

class Person
{
public:
  Person(const char* name)
    :_name(name)
  {
    cout << "Person(const char* name)" << 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;//姓名
};

class Student : public Person
{
public:
  Student(const char* name = "", int num = 0)
    :_num(num)
    ,Person(name)
  {
    cout << "Student(const char* name = "", int num = 0)" << endl;
  }

  //拷贝构造
  Student(const Student& s)
    :Person(s)
    ,_num(s._num)
  {
    cout << "Student(const Student& s)" << endl;
  }

  //赋值构造
  // s1 = s3
  Student& operator=(const Student& s)
  {
    if (this != &s)
    {
      Person::operator=(s);
      _num = s._num;
    }
    cout << "Student& operator=(const Student& s)" << endl;

    return *this;
  }

  //父类和子类析构函数构成隐藏关系
  //原因：多态的需要，析构函数名同意会被处理成destructor()
  //为了保证析构的顺序，先子后父
  //子类析构函数完成后会自动调用父类析构函数,所以不需要我们显示调用
  ~Student()
  {
    //父类的析构函数我们不需要显示调用
    //Person::~Person();
    cout << "~Student()" << endl;
  }
protected:
  int _num; //学号

[ C++ ] 继承

5. 继承与友元

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

如果要在Student类内访问Person的友元函数，必须在Student类内提供友元函数

class Student;
class Person
{
public:
  friend void Display(const Person& p, const;
protected:
  string _name; // 姓名
};

class Student : public Person
{
  friend void Display(const Person& p, const;
protected:
  int _stuNum; // 学号
};

void Display(const Person& p, const{
  cout << p._name << endl;
  //要想访问到Student中的保护成员，要提供友元函数

[ C++ ] 继承

6. 继承与静态成员

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

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

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; // 研究科目
};
//
int main(){
  Student s1;
  Student s2;
  Student s3;
  Graduate s4;
  Person s;

  cout << " 人数 :" << Person::_count << endl;
  cout << " 人数 :" << Student::_count << endl;
  cout << " 人数 :" << s4._count << endl;

  //同一个地址
  cout << " 人数 :" << &Person::_count << endl;
  cout << " 人数 :" << &Student::_count << endl;
  cout << " 人数 :" << &s4._count << endl;

  return 0;
}

[ C++ ] 继承

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

7. 菱形继承，菱形虚拟继承

单继承：一个子类只有一个直接父类

[ C++ ] 继承

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

[ C++ ] 继承

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

[ C++ ] 继承

7.1 菱形继承的问题

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

class Person
{
public:
  string _name; // 姓名
  int _a[10000]; //会有多份_a
};
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; // 主修课程

[ C++ ] 继承

这样会有二义性无法明确知道访问的是哪一个，因此需要我们显示指定访问那个父类的成员可以解决二义性问题，但是数据冗余问题无法解决。

7.2 虚拟继承

虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在Student和Teacher的继承Person时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地

方去使用。

class A
{
public:
  int _a;
  //static int _a;
};

//int A::_a = 0;

//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

[ C++ ] 继承

8. 总结

多继承存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题
继承和组合 1. public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。 2. 组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。
在继承方式中，基类的内部细节对子类可见。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
对象组合是类继承之外的另一种复用选择。对象组合要求被组合的对象具有良好定义的接口

因为对象的内部细节是不可见的。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合。

// Car和BMW Car和Benz构成is-a的关系
class Car {
protected:
  string _colour = "白色"; // 颜色
  string _num = "陕ABIT00"; // 车牌号
};

class BMW : public Car {
public:
  void Drive(){ cout << "好开-操控" << endl; }
};

class Benz : public Car {
public:
  void Drive(){ cout << "好坐-舒适" << endl; }
};

// Tire和Car构成has-a的关系

class Tire {
protected:
  string _brand = "Michelin";  // 品牌
  size_t _size = 17;         // 尺寸
};

class Car {
protected:
  string _colour = "白色"; // 颜色
  string _num = "陕ABIT00"; // 车牌号
  Tire _t; // 轮胎

[ C++ ] 继承

1.继承的概念和定义

1.1继承的概念

1.2 继承定义

1.2.1定义格式

1.2.2 继承关系和访问限定符

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

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

3. 继承中的作用域

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

5. 继承与友元

6. 继承与静态成员

7. 菱形继承，菱形虚拟继承

7.1 菱形继承的问题

7.2 虚拟继承

8. 总结

继续阅读

Learning Python Part IV 之属性继承搜索(Attribute Inheritance Search)

super与构造方法

07 面向对象编程-结构、封装、继承、多态、接口Struct定义struct 方法工厂模式面向对象三大特性

Scala学习--面向对象编程之继承

【Java】16.面向对象之继承·上（概念、作用、语法、protected、final、类加载、继承类型）

夯实Java基础系列23：深入理解Java继承、封装、多态的底层实现原理

微信小游戏基础（二） - 继承

java中super关键字的使用

python单继承中super()用法

Python 多重继承 mro

python（一）：python高级语法——多继承以及MRO顺序

java继承后构造函数的继承机制

Qt 中实现在控件中点击鼠标，就在鼠标点击处加载图片的方法

Python入门笔记7 - 面向对象编程一、面向对象编程OOP二、类和对象三、数据封装四、继承五、多态六、获取对象信息

2. Java 类继承详解（知识点梳理总结）版本1、定义2、创建子类3、继承的基本规则4、阻止继承5、构造子类对象6、super 关键字

Java中传值与传址、static、继承、重写、super