1. 继承的概念和意义

类之间的关系

在c++中，类之间可以有直接的关联关系，包括组合关系和继承关系。

• 组合关系：整体与部分的关系
• 继承关系：父子关系

组合关系

组合关系描述的是类之间整体与部分的关系，具有以下特点

• 将其他类的对象作为当前类的成员变量使用
• 当前类的对象与成员对象的生命期相同
• 成员对象在用法上与普通对象完全一致，具有等同地位

/*描述class的组合关系*/  #include <iostream> #include <string>  using namespace std;  class memory { public:     memory()     {         cout << "memory()" << endl;     }     ~memory()     {         cout << "~memory()" << endl;     } };  class disk { public:     disk()     {         cout << "disk()" << endl;     }     ~disk()     {         cout << "~disk()" << endl;     } };  class cpu { public:     cpu()     {         cout << "cpu()" << endl;     }     ~cpu()     {         cout << "~cpu()" << endl;     } };  class mainboard { public:     mainboard()     {         cout << "mainboard()" << endl;     }     ~mainboard()     {         cout << "~mainboard()" << endl;     } };  class computer { private:     /*必须是其他类的对象，不能是指针，否则无法构成组合关系*/     memory mmem;     disk mdisk;     cpu mcpu;     mainboard mmainboard; public:     computer()     {         cout << "computer()" << endl;     }     void power()     {         cout << "power()" << endl;     }     void reset()     {         cout << "reset()" << endl;     }     ~computer()     {         cout << "~computer()" << endl;     } };  int main() {     computer c;      return 0; }

继承关系

继承关系描述的是类之间的父子关系，父类为基类，子类为派生类。

• 子类拥有父类的所有属性和方法，还可以添加父类没有的属性和方法
• 子类是一种特殊的父类，子类对象可以当作父类对象使用，可以初始化父类对象，也可以给父类对象赋值
• 继承是c++中代码复用的重要手段，通过继承，可以获得父类的所有功能，还可以在子类中重写已有功能，或者添加新功能

#include <iostream> #include <string>  using namespace std;  class hpbook : public computer  //computer是组合关系示例代码中实现的类 {     string mos; public:     hpbook()     {         mos = "windows 8";     }     void install(string os)     {         mos = os;     }     void os()     {         cout << mos << endl;     } };  class macbook : public computer { public:     void os()     {         cout << "mac os" << endl;     } };  int main() {     hpbook hp;      hp.power();     hp.install("ubuntu 16.04 lts");     hp.os();      cout << endl;      macbook mac;      hp.power();     mac.os();      cout << endl;      return 0; }

建议：作为类设计的一般原则，能用组合关系的，就不要用继承关系，前提是组合关系可以实现所需功能和较好的架构设计。

2. 继承中的访问级别

• 面向对象中的访问级别包括public、private和protected
• protected是专门为了继承而设计的
• protected成员变量不能被外界直接访问，但可以被子类直接访问
• 在设计类的时候，需要根据具体需求来规划不同的访问级别

#include <iostream> #include <string>  using namespace std;  class parent { protected:     int mv; public:     parent()     {         mv = 100;     }      int value()     {         return mv;     } };  class child : public parent { public:     int addvalue(int v)     {         mv = mv + v;     } };  int main() {     parent p;     child c;      // p.mv = 1000;   // error     // c.mv = 10000;  // error      c.addvalue(50);     cout << "c.mv = " << c.value() << endl;      return 0; }

上面的demo简单地展示了protecded成员变量的特性和使用方式，下面再看一个复杂一些的综合示例，uml类图如下所示，
polint和line都继承自object，同时line还组合使用了point。

#include <iostream> #include <sstream> #include <string>  using namespace std;  class object { protected:     string mname;     string minfo; public:     object()     {         mname = "object";         minfo = "null";     }      string name()     {         return mname;     }      string info()     {         return minfo;     } };  class point : public object { private:     int mx;     int my; public:     point(int x = 0, int y = 0)     {         ostringstream s;          mx = x;         my = y;         mname = "point";          s << "p(" << mx << ", " << my << ")";          minfo = s.str();     }      int x()     {         return mx;     }      int y()     {         return my;     } };  class line : public object { private:     point mstart;     point mend; public:     line(point start, point end)     {         ostringstream s;          mstart = start;         mend = end;         mname = "line";          s << "line from " << mstart.info() << " to " << mend.info();          minfo = s.str();     }      point &begin()     {         return mstart;     }      point &end()     {         return mend;     } };  int main() {     object o;      cout << o.name() << endl;     cout << o.info() << endl;     cout << endl;      point p(1, 2);      cout << p.name() << endl;     cout << p.info() << endl;     cout << endl;      point start(3, 4);     point end(5, 6);     line l(start, end);      cout << l.name() << endl;     cout << l.info() << endl;      return 0; }

3. 不同的继承方式

类似于成员变量有三种访问级别，c++也支持三种不同的继承方式

• public继承：父类成员变量在子类中保持原有访问级别
• private继承：父类成员变量在子类中全部变为private
• protecded继承：父类public成员变量在子类中变为protected，其余成员变量访问级别保持不变

虽然c++支持三种不同的继承方式，但private和protected继承带来的复杂性远大于实用性，因此在工程中一般推荐使用public继承。
实际上，c++的派生语言（如java、c#）都只支持public继承这一种方式，也变相说明了这一点。

4. 继承中的构造与析构

父类和子类都可以定义构造函数，其中子类构造函数必须对继承而来的成员变量进行初始化，初始化的方法有两种：

• 直接使用赋值的方式进行初始化，仅适用于父类public和protected成员
• 调用父类构造函数进行初始化，这里也有两种调用方式
  • 隐式调用：适用于父类无参构造函数和默认参数构造函数
  • 显式调用：通过初始化列表进行调用，适用于所有父类构造函数

继承中的构造与析构顺序，在“对象的构造与析构（二）”中已经讲过，不再赘述。

#include <iostream> #include <string>  using namespace std;  class parent { protected:     string ps;     int mv; public:     parent()     {         cout << "parent()" << endl;         ps = "default";         mv = 0;     }      parent(string s, int v)     {         cout << "parent(string s, int v) : " << s << ", " << v << endl;         ps = s;         mv = v;     }      ~parent()     {         cout << "~parent() : " << ps << ", " << mv << endl;     } };  class child : public parent { private:     string cs; public:     /*      * 进入child()前，隐式调用parent()，初始化父类成员;      * 进入child()后，使用赋值方式，初始化父类成员.     */     child()     {         cout << "child()" << endl;         ps = "parent default";         mv = 100;         cs = "default";     }      /*      * 进入child()前，使用初始化列表，显式调用parent(string s, int v)，初始化父类成员.     */     child(string s) : parent(s, 200)     {         cout << "child(string s) : " << s << endl;         cs = s;     }      ~child()     {         cout << "~child() : " << cs << endl;     } };  int main() {     child c1;     child c2("child");      cout << endl;      return 0; }