【C++】继承-阿里云开发者社区

继承的概念

继承是面向对象的三大特性之一

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

之前我们经常使用函数的复用，继承是类设计层次的复用。

基本了解了继承的概念，下面对继承进行详细的讲解：

我们在这里设计一个person（人）的类，用来描述一个人的姓名，年龄，性别。

class Person
{
public:
  Person()
    :_name("空")
    ,_age(18)
    ,_sex("男")
  {}
private:
  string _name;
  int _age;
  string _sex;
};

这是按照我们之前的思路设计的一个person的类，但是这里需要先将private改为protected，以前的学习中我们知道，俩者是相同的，但是在学习继承开始，俩者将会不同。

class Person
{
public:
  Person()
    :_name("张三")
    , _age(18)
    , _sex("男")
  {}
protected:
  string _name;
  int _age;
  string _sex;
};

此时，当我们有一个person（人）的类之后，假设我们需要student，teacer等等拥有person的特征，但是在person的特征之上又存在各种特性，我们可以将person这个类当作一个基类（即所有的类都有的特征），将student、teacher称为person这个基类的派生类。

class Person
{
public:
  Person()
    :_name("张三")
    , _age(18)
    , _sex("男")
  {}
protected:
  string _name;
  int _age;
  string _sex;
};
class Student : public Person
{
public:
private:
  int _student_id;//学号
  string _major;//专业
 };
class Teacher : public Person
{
public:
private:
  int _job_number;//工号
};

继承定义

定义格式

在之前的介绍之后，我们可以将Person称为父类，也称为基类；

Student称为子类，也称为派生类。

继承关系

继承方式

public继承

protected继承

private继承

访问限定符

public访问

protected访问

private访问

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

类成员/继承方式	public继承	protected继承	private继承
基类的public成员	派生类的public成员	派生类的protected成员	派生类的private成员
基类的protected成员	派生类的protected成员	派生类的protected成员	派生类的private成员
基类的private成员	在派生类中不可见	在派生类中不可见	在派生类中不可见

【总结】

基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
基类private成员在派生类中是不能被访问，如果基类成员不想再类外直接访问，但需要再派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
通过表格的总结可以发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private .
使用关键子class时默认的继承方式是private，使用struct时默认的继承方式时public，不过最好显示的写出继承方式。
在实际运用中一般使用都是public继承，几乎很少使用protected/private继承，也不提倡使protected/private继承，因为protected/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

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

我们需要先搞清楚一个概念：基类可以和派生类相互赋值吗？可以看看下面的代码。

Person p;
  Student s;
  p = s;
  s = p;

这里需要了解的是，派生类的成员一定是大于等于基类的，派生类可以赋值给基类，是由于派生类中的成员变量包含了基类中的成员变量，而基类中只有自己类中的成员，没有派生类的，所以基类不能赋值类派生类。

派生类对象可以赋值给基类的对象、基类的指针、基类的引用。这里有个形象的说法叫做切片或者切割。寓意是把派生类中的基类部分切出去并赋值。

Student s;
  Person p = s;
  Person* pp = &s;
  Person& rp = s;

前面也就可以以及派生类对象可以赋值给基类的对象，那么过程中会不会产生临时变量呢？

int i = 10;
  double d = i;

我们都知道，将i赋值给d会产生临时变量，并且会进行类型转换。

int i = 10;
  double& d = i;

这里就不会产生临时变量，而是使用了引用。但是这段代码明显是错误的，原因是权限被放大了。

int i = 10;
  const double& d = i;

使用const就可以将权限缩小。

Student s;
  Person p = s;

同样的道理，这句代码是没有问题的，是不需要加const的，这里可以知道，转换的过程中并没有产生临时变量，而引用派生类会将基类部分切割出来。

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

【注意】

基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针式指向派生类对象时才安全。这里的基类如果是多态类型，可以使用RTTI(Run-Time Type Information)的dynamic cast来进行识别后进行安全转换。（后续了解）

Student s;
  Person* pp = &s;
  //强制类型转换
  Student* ps = (Student* )pp;

继承中的作用域

一个问题：基类和派生类中可以定义同名对象吗？

class Person
{
public:
  Person()
    :_name("张三")
    , _num(111)
  {}
protected:
  string _name;
  int _num;
};
class Student : public Person
{
public:
protected:
  int _num = 112;
};

当我们在派生类中进行打印这个同名成员，看看会打印哪一个。

class Person
{
public:
  Person()
    :_name("张三")
    , _num(111)
  {}
protected:
  string _name;
  int _num;
};
class Student : public Person
{
public:
  void Printf()
  {
    cout << _name << endl;
    cout << _num << endl;
  }
protected:
  int _num = 112;
};

打印的是派生类中的成员。所以是基类和派生类中是可以定义同名对象的，而且还有一定的规则。

在继承体系中基类和派生类都有独特的作用域。
基类和派生类中有同名成员，派生类将屏蔽基类对同名成员的直接访问，这种情况被称为隐藏，也叫重定义。（在子类成员函数中，可以使用基类::基类成员显示访问）

class Person
{
public:
  Person()
    :_name("张三")
    , _num(111)
  {}
protected:
  string _name;
  int _num;
};
class Student : public Person
{
public:
  void Printf()
  {
    cout << _name << endl;
    cout << Person::_num << endl;
    cout << _num << endl;
  }
protected:
  int _num = 112;
};

这里需要清楚的是，如果存在同名成员，默认情况下会在最近的作用域中去找，寻找顺序分别是局部域（函数域）、类域、副类域、全局域。

需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
注意在实际中的继承体系中最好不要定义同名的成员。

派生类的默认成员函数

默认成员函数

初始化和清理

构造函数主要完成初始化工作

析构函数主要完成清理工作

拷贝赋值

拷贝构造是使用同类对象初始化创建对象

赋值重载主要是把一个对象赋值给另一个对象

取地址重载

主要是普通对象和const对象取地址,这俩个很少会自己实现

之前的学习过程中，六个默认成员函数，“默认”的意思就是我们自己不写，编译器会自动生成一个。下面介绍在派生类中，这几个成员函数是如何生成的。

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

class Person
{
public:
  Person()
    :_name("张三")
    , _age(18)
    , _sex("男")
  {}
protected:
  string _name;
  int _age;
  string _sex;
};
class Student : public Person
{
public:
  Student(const int& student_id = 1111111, const string& major = "计算机")
    :_student_id(student_id)
    , _major(major)
    ,Person()
  {}
private:
  int _student_id;//学号
  string _major;//专业
};

这种情况，会先默认构造基类，再构造派生类。

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

class Person
{
public:
  Person()
    :_name("张三")
    , _age(18)
    , _sex("男")
  {}
  Person(const Person& p)
    :_name(p._name)
    ,_age(p._age)
    ,_sex(p._sex)
  {}
protected:
  string _name;
  int _age;
  string _sex;
};
class Student : public Person
{
public:
  Student(const int& student_id = 1111111, const string& major = "计算机")
    :_student_id(student_id)
    , _major(major)
    ,Person()
  {}
  Student(const Student& s)
    :Person(s)
    ,_student_id(s._student_id)
    ,_major(s._major)
  {}
private:
  int _student_id;//学号
  string _major;//专业
};

派生类的operator=必须调用基类的operator=完成基类的赋值。

class Person
{
public:
  Person()
    :_name("张三")
    , _age(18)
    , _sex("男")
  {}
  Person(const Person& p)
    :_name(p._name)
    ,_age(p._age)
    ,_sex(p._sex)
  {}
  Person& operator=(const Person& p)
  {
    if (this != &p)
    {
      _name = p._name;
      _age = p._age;
      _sex = p._sex;
    }
  }
protected:
  string _name;
  int _age;
  string _sex;
};
class Student : public Person
{
public:
  Student(const int& student_id = 1111111, const string& major = "计算机")
    :_student_id(student_id)
    , _major(major)
    ,Person()
  {}
  Student(const Student& s)
    :Person(s)
    ,_student_id(s._student_id)
    ,_major(s._major)
  {}
  Student& operator=(const Student& s)
  {
    if (this != &s)
    {
      Person::operator=(s);
      _student_id = s._student_id;
      _major = s._major;
    }
  }
private:
  int _student_id;//学号
  string _major;//专业
};

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

class Person
{
public:
  Person()
    :_name("张三")
    , _age(18)
    , _sex("男")
  {}
  Person(const Person& p)
    :_name(p._name)
    ,_age(p._age)
    ,_sex(p._sex)
  {}
  Person& operator=(const Person& p)
  {
    if (this != &p)
    {
      _name = p._name;
      _age = p._age;
      _sex = p._sex;
    }
  }
  ~Person()
  {}
protected:
  string _name;
  int _age;
  string _sex;
};
class Student : public Person
{
public:
  Student(const int& student_id = 1111111, const string& major = "计算机")
    :_student_id(student_id)
    , _major(major)
    ,Person()
  {}
  Student(const Student& s)
    :Person(s)
    ,_student_id(s._student_id)
    ,_major(s._major)
  {}
  Student& operator=(const Student& s)
  {
    if (this != &s)
    {
      Person::operator=(s);
      _student_id = s._student_id;
      _major = s._major;
    }
  }
  ~Student()
  {}
private:
  int _student_id;//学号
  string _major;//专业
};

派生类对象初始化先调用基类构造再调用派生类的构造。
派生类对象析构清理会先调用派生类析构再调基类析构。

【注意】因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同（后续讲解）。那么编译器会对析构函数名进行特殊化处理，处理成destructor()，所以父类析构函数不加virtual的情况下，子类析构函数和父类析构函数构成隐藏关系。

继承和友元

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

class Student;
class Person
{
public:
  friend void Display(const Person& p, const Student& s);
protected:
  string _name; // 姓名
};
class Student : public Person
{
  friend void Display(const Person& p, const Student& s);
protected:
  int _stuNum; // 学号
};
void Display(const Person& p, const Student& s)
{
  cout << p._name << endl;
  cout << s._stuNum << endl;
}
void main()
{
  Person p;
  Student s;
  Display(p, s);
}

继承与静态成员

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

class A
{
public:
protected:
  int _num = 10;
public:
  static int _count;
};
int A::_count = 0;
class B
{
public:
protected:
  string _name = "li";
};

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

菱形继承与菱形虚拟继承

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

class Person
{
public:
  Person(const string& name = "张三")
    :_name(name)
  {}
protected:
  string _name;
};
class Student : public Person
{
public:
  Student(const int id = 0)
    :_id(id)
  {}
protected:
  int _id;
};

多继承：一个子类有俩个或者俩个意思直接父类时称这个继承关系为多继承。

class Student
{
public:
  Student(const int id = 0)
    :_id(id)
  {}
protected:
  int _id;
};
class Teacher
{
public:
  Teacher(const int card = 0)
    :_card(card)
  {}
protected:
  int _card;
};
class Assistant : public Student, public Teacher
{
public:
  Assistant(const int& num = 0)
    :_num(num)
  {}
protected:
  int _num;
};

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

class Person
{
public:
  Person(const string& name = "张三")
    :_name(name)
  {}
protected:
  string _name;
};
class Student : public Person
{
public:
  Student(const int id = 0)
    :_id(id)
  {}
protected:
  int _id;
};
class Teacher : public Person
{
public:
  Teacher(const int card = 0)
    :_card(card)
  {}
protected:
  int _card;
};
class Assistant : public Student, public Teacher
{
public:
  Assistant(const int& num = 0)
    :_num(num)
  {}
protected:
  int _num;
};

【注意】菱形继承的问题：菱形继承有数据冗余和二义性的问题。

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._a = 1;
  d._b = 2;
  d._c = 3;
  d._d = 4;
  return 0;
}

使用上述代码，在编译期间已经有一句代码出现问题。

在编译期间，编译器对_a的访问不明确，这样会存在二义性，无法明确知道访问的是哪一个。

D d;
  //d._a = 1;
  d.B::_a = 6;
  d.C::_a = 7;
  d._b = 2;
  d._c = 3;
  d._d = 4;

通过显示指定访问哪个基类的成员可以二义性的问题，但是数据冗余问题无法解决。

通过对底层代码的内存的了解，可以清楚的了解到_a有俩份，分别保存在俩个地方，即菱形继承的内存对象成员模型：这里可以看到数据冗余。

使用虚拟继承（virtual）可以解决菱形继承的二义性和数据冗余的问题。

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._a = 1;
  d._b = 2;
  d._c = 3;
  d._d = 4;
  return 0;
}

【注意】虚拟继承不要再其他地方去使用。

通过对菱形虚拟继承的内存对象成员模型的了解，将B和C的上面分别保存一个指针，指向了一张表。这俩个指针叫做虚机表指针，这俩个表叫虚机表。续集表中存的偏移量，通过偏移量可以找到A。

原理解释：

继承与组合的比较

C++语法复杂的体现，其实多继承就是一个体现。有了多继承，就会存在菱形继承，有了菱形继承就会有菱形虚拟继承，底层实现比较复杂。所以一般谨慎使用多继承，避免设计出菱形继承。
多继承可以认为是C++的缺陷之一，很多后来的OO语言都没有多继承，如java。
继承与组合

public继承是一种is-a的关系，也就是说每一个派生类对象都是一个基类对象。
组合是以一种has-a的关系，B组合了A，每一个B对象中都有一个A对象。
优先使用对象组合，而不是类继承。
继承允许根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常称为白箱复用。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对派生类可见。继承一定程度上破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或者组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
实际尽量多使用组合。组合的耦合度低，代码维护性好。不过继承也有被使用的地方，有些关系就适合继承，另外要实现多态也需要使用继承。类之间的关系可以使用继承，可以使用组合。

【C++】继承

继承的概念

继承定义

定义格式

继承关系

访问限定符

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

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

继承中的作用域

派生类的默认成员函数

继承和友元

继承与静态成员

菱形继承与菱形虚拟继承

继承与组合的比较

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【C++】继承

继承的概念

继承定义

定义格式

继承关系

访问限定符

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

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

继承中的作用域

派生类的默认成员函数

继承和友元

继承与静态成员

菱形继承与菱形虚拟继承

继承与组合的比较

热门文章

最新文章

相关课程

相关电子书

相关实验场景