【C++】从零开始认识继承(一)-阿里云开发者社区

送给大家一句话：

其实我们每个人的生活都是一个世界，即使最平凡的人也要为他生活的那个世界而奋斗。 – 路遥《平凡的世界》

从零开始认识继承

1 前言

在我们日常的编程中，继承的应用场景有很多。它可以帮助我们节省大量的时间和精力，避免重复造轮子的尴尬。同时，它也让我们的代码更加模块化，易于维护和扩展。可以说，继承技术是C++的灵魂。

那么，继承技术的起源又是什么呢？这得追溯到遥远的过去，当时的程序员们发现，许多类的属性和方法都是相似的，于是他们想出了一个绝妙的主意：为什么不把这些相似的部分提取出来，形成一个"父类"，而其他的类则通过"继承"这个父类来获得这些属性和方法呢？这个想法，就是继承技术的雏形。

如今，继承技术已经成为C++编程中不可或缺的一部分。它让我们能够站在巨人的肩膀上，创造出更加高效、简洁的代码。当然，继承技术也不是万能的，它也有自己的局限性和注意事项。但是，这并不妨碍我们欣赏它的优雅，感受它带来的便利。

在这篇博客中，我将带你深入探讨C++继承技术的奥秘，让你能够更好地掌握这一强大的工具。准备好了吗？让我们一起踏上这场探索之旅，开启编程的新篇章 — C++进阶！！！

2 什么是继承

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

通过继承联系在一起的类构成一种层次关系，通常在层次关系的根部有一个基类（base class）,其他类则是直接或间接地从基类继承过来的，这些继承来的类成为派生类（derived class）。基类负责定义在层次关系中所有类共同拥有的成员，而每个派生类都有各自特定的成员。

举个例子：加入我们需要一个学校管理系统，那么成员包括学生，老师，保安，宿管…不管是什么身份，总得是个人吧，是人就会有名字，年龄，家庭住址等基础信息，那么我们就可以把这些共同的部分提炼出来作为基类。

#include<iostream>

using namespace std;
//共同特性
class Person
{
public:
  void Print()
  {
    cout << "name:" << _name << endl;
    cout << "age:" << _age << endl;
  }
protected:
  string _name = "peter"; // 姓名
  int _age = 18; // 年龄
};

class Student : public Person
{
protected:
  int _stuid; // 学号
};

class Teacher : public Person
{
protected:
  int _jobid; // 工号
};
int main()
{
  Student s;
  Teacher t;
  s.Print();
  t.Print();
  return 0;
}

运行一下：

3 开始使用继承

3.1 继承的语法格式

class Student : public Person 这样就是继承的语法

继承方式在这里有三种:public , protected ， private。不同的继承方式与不同的类成员组合，会是不同的权限：

类成员 / 继承方式	public继承	protected继承	private继承

基类的public成员

会成为派生类的public成员

会成为派生类的protected成员

会成为派生类的private成员

基类的protected成员

会成为派生类的protected成员

会成为派生类的private成员

基类的private成员

在派生类中不可见

总结起来：

基类private成员在派生类中无论以什么方式继承都是不可见的！！！派生类无法直接访问基类的私有成员（可以间接访问），类外也无法访问。
如果基类的成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced / private继承，因为protetced / private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强
基类的其他成员在子类的访问方式等于(成员在基类的访问限定符，继承方式) 较小的那一个权限，public > protected> private。
通过继承的特性，基类一般都定义为public 和 protected，不使用private。

3.2 基类与派生类的赋值转换

在之前的学习中，我们知道相近类型的类型可以相互转换：

int i = 1 ;
double d = i;
string s = "111111";
const string& s = "111111";//类型转换会产生临时变量，临时变量具有常性

不相关的类型就无法进行转换。

那么在继承中，子类与父类可不可以进行赋值转换呢？可以！

只有公有继承才能进行转换！！！

Student st;
Person p = st;

在public继承中，有一个is-a概念：每个子类对象都是一个特殊的父类对象。父类 = 子类，会对子类进行切片，把父类的部分给基类进行赋值。

也可以使用引用和指针，同样也是通过切片来进行赋值。都可以对派生类进行修改。

引用
引用就是创建一个子类中基类部分的别名。
指针
指针就是将子类中基类的地址赋值给基类指针。

注意：

派生类对象可以赋值给基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。
基类对象不能赋值给派生类对象。
基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。这里基类如果是多态类型，可以使用RTTI(RunTime Type Information)的dynamic_cast 来进行识别后进行安全转换。

3.3 继承中的作用域

通过对C语言的C++的学习，我们知道有域这个概念。域分为局部域和全局域，相同的域不能有同名变量与同名函数（重载除外）。局部域与全局域会影响生命周期。而C++ 中又有了类域！类域不影响生命周期：

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

我们就来看看隐藏是怎么个事儿！

只要派生类中出现与基类相同的变量名，那么就会把父类的变量隐藏，想要访问父类的该变量，就需要加上限定域名：

#include<iostream>

using namespace std;

class Person
{
public:
  Person(int age = 18, int sex = 1, int num = 0)
    :_age(age),
    _sex(sex),
    _num(num)
  {}
  void Print()
  {
    cout<< _sex <<endl;
  }
protected:
  int _age;
  int _sex;
  //设置一个变量
  int _num;
};

class Student: public Person
{
public:
  Student(int num = 0)
    :_num(num)
  {

  }
  void Print()
  {
    cout <<"_num : " << _num << endl;
    cout <<"Person::_num : " << Person::_num << endl;

  }
protected:

  //设置一个变量
  int _num;
};

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

来看现象：

也就是基类变量和派生类变量具有不同的作用域，如果存在同名变量，派生类想要访问基类的变量就需要指明作用域。

函数也是同样的道理！！！如果有相同函数名，使用基类成员时要表明作用域。

3.4 派生类的默认成员函数

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

构造函数

首先派生类的成员可以分为以下几种：父类成员，子类成员，内置类型，自定义类型。

对于子类的成员，规则和普通的类一样（内置类型不做处理，自定义类型调用其构造函数）。如果没有默认构造，就会报错！！！

#include<iostream>

using namespace std;

class Person
{
public:
  //因为不是全缺省函数没有默认构造
  Person(const char* name )
    : _name(name)
  {
    cout << "Person()" << endl;
  }
protected:
  string _name; // 姓名
};
class Student : public Person
{
public:
protected:
  int _num; //学号
};
void Test()
{
  Student s1;
}

int main()
{
  Test();
  return 0;
}

因为没有写Student的构造函数，内置类型会不处理，自定义类型会调用其构造函数。

但是我们写了一个基类Person的全缺省构造函数，这里就会在没有传参的时候没有默认构造函数匹配，这时派生类Student就会报错：

为了避免这样的错误，我们可以增添派生类Student的构造函数：

class Student : public Person
{
public:
  Student(int num , const char* str ,const char* name)
    :_name(name),
    _num(num),
    _str(str)
  {

  }
protected:
  int _num; //学号
  string _str;
};

可是？？？为什么这样

因为这里的继承的Person相当于我们有一个Person成员变量，就是一个整体，我们要调用它的整体：

class Student : public Person
{
public:
  Student(int num , const char* str ,const char* name)
    :Person(name),
    _num(num),
    _str(str)
  {

  }
protected:
  int _num; //学号
  string _str;
};

把基类当做一个整体就可以了！！！，类似以下结构：

class BBclass BB
{
public:
  BB(int num , const char* str ,const char* name)
    :_p(name),
    _num(num),
    _str(str)
  {}
protected:
  Person _p
  int _num; //学号
  string _str;
};

拷贝构造函数

再来看拷贝构造，拷贝构造的基类是如何处理的呢？

依然采取：对于子类的成员，规则和普通的类一样（内置类型不做处理，自定义类型调用其拷贝构造函数）

如果没有就默认生成（浅拷贝）！！！涉及深拷贝要写哦，一般不需要写。

写的规则与构造函数类似：

class Student : public Person
{
public:
  Student(int num , const char* str ,const char* name)
    :Person(name),
    _num(num),
    _str(str)
  {}
  Student(const Student& s)
    :Person(s)//会进行切片，子类对象可以赋值给父类  ->复用
    ,_num(s._num)
    ,_str(s._str)
  {}
protected:
  int _num; //学号
  string _str;
};

Person(s) 会进行切片（子类对象可以赋值给父类），这样是对基类代码的复用！

赋值构造函数

赋值构造函数operator=怎样进行操作呢？

默认生成的赋值构造也是差不多的逻辑：对于子类的成员，规则和普通的类一样（内置类型不做处理，自定义类型调用其赋值构造函数 operator=）

那要是存在深拷贝，需要我们来自己写：

class Student : public Person
{
public:
  Student(int num , const char* str ,const char* name)
    :Person(name),
    _num(num),
    _str(str)
  {}
  Student& operator=(const Student& s)
  {
    //不能自己赋值自己
    if(this != &s)
    {
      //注意标明作用域 ， 否则会无限递归
      Person::operator=(s); //进行切片来对父类进行赋值拷贝 ->复用
      _num = s._num;
      _str = s._str;//调用string的构造
    }
  }
protected:
  int _num; //学号
  string _str;
};

子类的赋值构造会隐藏父类的赋值构造！！！

一定一定注意Person::operator=(s);一定一定指明作用域，不然会就近原则调用派生类的operator=函数，然后无限递归，最终导致栈溢出！！！

class Student : public Person
{
public:
  Student(int num , const char* str ,const char* name)
    :Person(name),
    _num(num),
    _str(str)
  {}
  ~Student(int num , const char* str ,const char* name)
  {
    ~Person();
    cout<<" ~Student() "<<endl;
  }
protected:
  int _num; //学号
  string _str;
};

析构函数

析构函数是可以主动调用的。那么我们很自然的想到在派生类析构函数中调用基类析构：

但是报错了？？？

因为子类的析构也会隐藏父类的析构！！！对于以后多态的需要，一般析构函数名都会统一处理为destructor

想要调用就标明作用域：Person::~Person(),但是像上述这样写，会有一个问题，基类的析构会调用两次！！！

那怎么办呢？？？

其实，派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。所以我们不必在派生类的析构函数中进行调用基类的析构函数，不然就会重复释放同一块空间，导致报错！

因为析构必须要按先子后父的顺序，父亲没了何谈子呢？父亲析构了，如果子类还要访问父类成员，那子类中对父类的访问就会出现问题，野指针什么的问题接踵而至！！！

总结

派生类的默认成员函数的注意事项：

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

【C++】从零开始认识继承(一)