继承和派生

01 继承和派生的概念

继承：

• 在定义一个新的类 b 时，如果该类与某个已有的类 a 相似（指的是 b 拥有 a 的全部特点），那么就可以把 a 作为一个基类，而把b作为基类的一个派生类（也称子类）。

派生类：

• 派生类是通过对基类进行修改和扩充得到的，在派生类中，可以扩充新的成员变量和成员函数。
• 派生类拥有基类的全部成员函数和成员变量，不论是private、protected、public。需要注意的是：在派生类的各个成员函数中，不能访问基类的private成员。

02 需要继承机制的例子

程序猿种类有很多种，如 c/c++ 程序猿，java 程序猿，python 程序猿等等。那么我们要把程序猿设计成一个基类， 我们则需要抽出其特有的属性和方法。

所有程序猿的共同属性（成员变量）：

1. 姓名
2. 性别
3. 职位

所有的程序猿都有的共同方法（成员函数）：

1. 是否要加班？
2. 是否有奖励？

而不同的程序猿，又有各自不同的属性和方法：

• c++ 程序猿：是否是音视频、网游领域
• java 程序猿：是否是微服务领域
• python 程序猿：是否是人工智能、大数据领域

03 派生类的写法

继承的格式如下：

class 派生类名：public 基类名 {      };

程序猿 coder 基类：

class coder { public:     bool isworkovertime(){}        // 是否要加班          bool isreward(){}              // 是否有奖励          void set(const string & name)  // 设置免费精选名字大全     {         m_name = name;     }          ...      private:     string m_name; // 姓名     string m_post; // 职位     int m_sex;     // 性别 };

python 程序猿 pythoncoder 派生类：

class pythoncoder : public coder { public:     bool isaifield(){}      // 是否是人工智能领域     bool isbigdatafield(){} // 是否是大数据领域 };

04 派生类对象的内存空间

派生类对象的大小 = 基类对象成员变量的大小 + 派生类对象自己的成员变量的大小。在派生类对象中，包含着基类对象，而且基类对象的存储位置位于派生类对象新增的成员变量之前，相当于基类对象是头部。

class cbase {     int a1;     int a2; };  class cderived : public cbase {     int a3;     };

继承关系和复合关系

01 类之间的两种关系

继承的关系是「是」的关系：

• 基类 a，b 「是」基类 a 的派生类。
• 逻辑上要求：一个 b 对象也「是」一个 a 对象。

继承的关系是「有」的关系：

• c 类中「有」成员变量 i，i 成员变量是 d 类的，则 c 和 d 是复合关系。
• 逻辑上要求：d 对象是 c 对象的固有属性或组成部分。

02 继承关系的使用

假设已经存在了 man 类表示男人，后面需要些一个 women 类来表示女人。man 类和 women 类确实是有共同之处，那么就让 women 类继承 man 类，是否合适？

我们先想想继承的逻辑要求，假设 women 类继承 man 类后的逻辑就是：一个女人也是一个男人。很明显，这显然不成立！

所以，好的做法是概括男人和女人的共同特点，抽象出一个 human 类表示人，然后 man 和 woman 都继承 human 类。

03 复合关系的使用

假设要写一个小区养狗管理系统：

• 需要写一个「主人」类。
• 需要些一个「狗」类。

假定狗只有一个主人，但是一个主人可以最多有 10 条狗，应该如何设计和使用「主人」类 和「狗」类呢？我们先看看下面几个例子：

例子一：

• 为主人类设一个狗类的成员对象数组；
• 为狗类设一个主人类的成员对象。

class cdog; class cmaster // 主人类 {     cdog dogs[10]; // 狗类的成员对象数组 };  class cdog  // 狗类 {     cmaster m;   // 主人类的成员对象 };

例子一可以发现是：

• 主人类会构造 10 个狗对象
• 狗类会构造 1 个主人对象

相当于人中有狗，狗中有人：

这样是不好的，因为会产生循环不断的构造，主人类构造狗对象，狗类又构造主人对象….

例子二：

• 为狗类设一个主人类的成员对象；
• 为主人类设一个狗类的对象指针数组。

class cdog; class cmaster // 主人类 {     cdog * pdogs[10]; // 狗类的对象指针数组 };  class cdog  // 狗类 {     cmaster m;   // 主人类的成员对象 };

这样又变成狗中有人，人去指向「狗中有人」的狗，关系就会显得很错乱，如下图：

例子三：

• 为狗类设一个主人类的对象指针；
• 为主人类设一个狗类的对象数组。

class cdog; class cmaster // 主人类 {     cdog  dogs[10]; // 狗类的对象数组 };  class cdog  // 狗类 {     cmaster * pm;   // 主人类的对象指针 };

这样就会变成，人中有狗，人里面的狗又会指向主人，虽然关系相对好了一点，但是同样还是会绕晕，效果如下图：

例子四：

• 为狗类设一个主人类的对象指针；
• 为主人类设一个狗类的对象指针数组。

class cdog; class cmaster // 主人类 {     cdog  * pdogs[10]; // 狗类的对象指针数组 };  class cdog  // 狗类 {     cmaster * pm;   // 主人类的对象指针 };

这个是正确的例子，因为相当于人和主人是独立的，然后通过指针的作用，使得狗是可以指向一个主人，主人也可以同时指向属于自己的 10 个狗，这样会更灵活。

04 指针对象和对象的区别

如果不用指针对象，生成 a 对象的同时也会构造 b 对象。用指针就不会这样，效率和内存都是有好处的。

比如：

class car {     engine engine; // 成员对象     wing * wing;   // 成员指针对象 };

定义一辆汽车，所有的汽车都有 engine，但不一定都有 wing
这样对于没有 wing 的汽车，wing 只占一个指针，判断起来也很方便。

• 空间上讲，用指针可以节省空间，免于构造 b 对象，而是只在对象中开辟了一个指针，而不是开辟了一个对象 b 的大小。
• 效率上讲，使用指针适合复用。对象 b 不但 a 对象能访问，其他需要用它的对象也可以使用。
• 指针对象可以使用多态的特性，基类的指针可以指向派生链的任意一个派生类。
• 指针对象，需要用它的时候，才需要去实例化它，但是在不使用的时候，需要手动回收指针对象的资源。

派生类覆盖基类成员

01 覆盖

派生类（子类）可以定义一个和基类（父类）成员同名的成员，这叫「覆盖」。在派生类（子类）中访问这类成员时，默认的情况是访问派生类中定义的成员。要在派生类中访问由基类定义的同名成员时，要使用作用域符号::。

下面看具体的例子：

// 基类 class father { public:     int money;     void func(); };    // 派生类 class son : public father // 继承 { public:     int money;   // 与基类同名成员变量     void func(); // 与基类同名成员函数          void myfunc();  };  void son::myfunc() {     money = 100;         // 引用的是派生类的money     father::money = 100; // 引用的是基类的money          func();           // 引用的是派生类的     father::func();   // 引用的是基类的 }

相当于 son 对象占用的存储空间：

类的保护成员

我们都知道基类的 public 成员，都是可以被派生类成员访问的，那么基类的 protected、private 成员，分别可以被派生类成员访问吗？带着这个问题，我们可以先看下面的栗子：

class father { public:     int npublic;   // 公有成员 protected:     int nprotected; // 保护成员 private:     int nprivate;   // 私有成员 };  class son : public father {     void func()     {         npublic = 1;     // ok         nprotected = 1;  // error         nprivate =1;     // ok，访问从基类继承的protected成员                  son a;         a.nprotected = 1; // error,a不是当前对象     }      };  int main() {          father f;     son s;          f.npublic;  // ok     s.npublic;  // ok          f.nprotected; // error     s.nprotected; // error          f.nprivate;  // error     s.nprivate;  // error }  

基类的 protected、private 成员对于派生类成员的权限说明:
基类的 protected 成员 | 基类的 private 成员
—|—
派生类的成员函数可以访问当前对象的基类的保护成员| 不能被派生类成员访问

派生类的构造函数

通常在初始化派生类构造函数时，派生类构造函数是要实现初始化基类构造函数的。那么如何在派生类构造函数里初始化基类构造函数呢？

class bug { private :     int nlegs; int ncolor; public:     int ntype;     bug (int legs, int color);     void printbug (){ }; };  class flybug : public bug  // flybug 是bug 的派生类 {     int nwings; public:     flybug( int legs,int color, int wings); };  bug::bug( int legs, int color) {     nlegs = legs;     ncolor = color; }  // 错误的flybug 构造函数 flybug::flybug ( int legs,int color, int wings) {     nlegs = legs;   //  不能访问     ncolor = color; //  不能访问     ntype = 1;      // ok     nwings = wings; }  // 正确的flybug 构造函数： flybug::flybug ( int legs, int color, int wings):bug( legs, color) {     nwings = wings; }  int main()  {     flybug fb ( 2,3,4);     fb.printbug();     fb.ntype = 1;     fb.nlegs = 2 ; // error. nlegs is private     return 0; }

在上面代码例子中：

第24-30行的派生类构造函数初始化基类是错误的方式，因为基类的私有成员是无法被派生类访问的，也就无法初始化。

第33-36行代码是正确派生类构造函数初始化基类构造函数的方式，通过调用基类构造函数来初始化基类，在执行一个派生类的构造函数
之前，总是先执行基类的构造函数。

从上面的例子中我们也得知构造派生对象前，是先构造基类对象，那么在析构的时候依然依据“先构造，后初始化”的原则，所以派生类析构时，会先执行派生类析构函数，再执行基类析构函数。

如下栗子：

class base  { public:     int n;          base(int i) : n(i)     {         cout << "base " << n << " constructed" << endl;     }          ~base()     {          cout << "base " << n << " destructed" << endl;      } };  class derived : public base  { public:     derived(int i) : base(i)     {          cout << "derived constructed" << endl;      }          ~derived()     {          cout << "derived destructed" << endl;     } };  int main()  {      derived obj(3);   return 0;  }

输出结果：

base 3 constructed derived constructed derived destructed base 3 destructed

继承的赋值兼容规则

01 public 继承

// 基类 class base {};  // 派生类 class derived : public base {};  base b;    // 基类对象 derived d; // 派生类对象

1. 派生类的对象可以赋值给基类对象

b = d;

1. 派生类对象可以初始化基类引用

base & br = d;

1. 派生类对象的地址可以赋值给基类指针

base * pb = & d;

==注意：如果派生方式是 private 或 protected，则上述三条不可行==

02 protected 和 private 继承

// 基类 class base {};  // 派生类 class derived : protected base {};  base b;    // 基类对象 derived d; // 派生类对象

• protected 继承时，基类的 public 成员和 protected 成员成为派生类的 protected 成员；
• private 继承时，基类的 public 成员成为派生类的 private 成员，基类的 protected 成员成
  为派生类的不可访问成员；
• protected 和 private 继承不是「是」的关系。

所以派生方式是 private 或 protected，则是无法像 public 派生承方式一样把派生类对象赋值、引用、指针给基类对象。

03 基类与派生类的指针强制转换

public 派生方式的情况下，派生类对象的指针可以直接赋值给基类指针

base *ptrbase = & objderived;

• ptrbase 指向的是一个 derived 派生类（子类）的对象
• *ptrbase 可以看作一个 base 基类的对象，访问它的 public 成员直接通过 ptrbase 即可，但不能通过 ptrbase 访问 objderived 对象中属于 derived 派生类而不属于基类的成员。

通过强制指针类型转换，可以把 ptrbase 转换成 derived 类的指针

base * ptrbase = &objderived; derived *ptrderived = ( derived * ) ptrbase;

程序员要保证 ptrbase 指向的是一个 derived 类的对象，否则很容易会出错。