Updated to Chapter 10, Section 5

Author: cppHusky

code_in_book/10.1/Header.h

@@ -9,8 +9,7 @@ struct Shape { //抽象基类，这个类用来表示各种几何图形
         return rad * 180 / Pi;
     }
     virtual double perimeter()const = 0; //周长，纯虚函数
-    virtual double area()const = 0; //周长，纯虚函数
-    virtual ~Shape() {} //析构，虚函数
+    virtual double area()const = 0; //面积，纯虚函数
 };
 class Triangle : public Shape { //三角形
     double _a;
@@ -19,8 +18,8 @@ class Triangle : public Shape { //三角形
 public:
     Triangle(double a, double b, double c)
         : _a {a}, _b {b}, _c {c} {} //构造函数
-    virtual double perimeter()const { return _a + _b + _c; } //周长
-    virtual double area()const { //面积
+    double perimeter()const { return _a + _b + _c; } //周长
+    double area()const { //面积
         double s {(_a + _b + _c) / 2};
         return std::sqrt(s * (s - _a) * (s - _b) * (s - _c));
     }
@@ -29,8 +28,8 @@ class Circle : public Shape { //圆形
     double _r; //圆的半径
 public:
     Circle(double r) : _r {r} {}
-    virtual double perimeter()const { return 2 * Pi * _r; } //周长
-    virtual double area()const { return Pi * _r * _r; } //面积
+    double perimeter()const { return 2 * Pi * _r; } //周长
+    double area()const { return Pi * _r * _r; } //面积
 };
 class Parallelogram_abc : public Shape { // 抽象平行四边形基类
 protected:
@@ -47,17 +46,34 @@ class Parallelogram : public Parallelogram_abc { //平行四边形
     double perimeter()const { return 2 * (_a + _b); }
     double area()const { return _a * _b * std::sin(Deg2Rad(_theta)); }
 };
-struct Rhombus_abc : Parallelogram_abc { //抽象菱形基类
-    double perimeter()const { return 4 * _a; }
-    Rhombus_abc(double a) : Parallelogram_abc {a} {} //构造函数
+struct Rhombus_abc : virtual public Parallelogram_abc { //抽象菱形基类
+    Rhombus_abc(double a) : Parallelogram_abc {a} {}
+    double perimeter()const { return 4 * _a; } //菱形、正方形通用的周长公式
+};
+struct Rectangle_abc : virtual public Parallelogram_abc { //抽象矩形基类
+    Rectangle_abc(double a) : Parallelogram_abc {a} {}
 };
 class Rhombus : public Rhombus_abc { //菱形
     double _theta;
 public:
-    Rhombus(double a, double theta) : Rhombus_abc {a}, _theta {theta} {}
+    Rhombus(double a, double theta)
+        : Parallelogram_abc {a}, Rhombus_abc {a}, _theta {theta} {}
+    //因为Rhombus_abc虚继承自Parallelogram_abc，我们必须单独调用后者的构造函数
+    //又因为Rhombus继承自Rhombus_abc，我们必须调用后者的构造函数
     double area()const { return _a * _a * std::sin(Deg2Rad(_theta)); }
 };
-struct Square : Rhombus_abc { //正方形
-    Square(double a) : Rhombus_abc {a} {}
+class Rectangle : public Rectangle_abc { //矩形
+    double _b;
+public:
+    Rectangle(double a, double b)
+        : Parallelogram_abc {a}, Rectangle_abc {a}, _b {b} {}
+    //同上，不再赘述
+    double perimeter()const { return 2 * (_a + _b); }
+    double area()const { return _a * _b; }
+};
+struct Square : Rhombus_abc, Rectangle_abc { //正方形
+    Square(double a)
+        : Parallelogram_abc {a}, Rhombus_abc {a}, Rectangle_abc {a} {}
     double area()const { return _a * _a; }
+    //perimeter函数继承自Rhombus_abc足矣，不必再写
 };

generalized_parts/09_class_inheritance/04_sequential_inheriance.tex

@@ -66,7 +66,7 @@ \subsection*{生物分类法}
     //...
 };
 \end{lstlisting}\par
-这样一来，赤狐种 \lstinline@Vulpes_vulpes@ 和家犬亚种 \lstinline@Canis_lupus_familaries@ 就在相同的特怔方面继承同一个类，而在各自的特性上又有自己的一套。就这样，面对这样错综复杂的关系，C++可以通过继承功能，把它们梳理得十分清晰。\par
+这样一来，赤狐种 \lstinline@Vulpes_vulpes@ 和家犬亚种 \lstinline@Canis_lupus_familaries@ 就在相同的特征方面继承同一个类，而在各自的特性上又有自己的一套。就这样，面对这样错综复杂的关系，C++可以通过继承功能，把它们梳理得十分清晰。\par
 \subsection*{C++流输入/输出库}
 C++的流输入/输出库是一个系统，包含 \lstinline@iostream@, \lstinline@fstream@, \lstinline@sstream@ 等许多库文件，\lstinline@std::istream@, \lstinline@std::ostream@ 等许多我们已经熟知的类模版或类。它们之间有一套复杂的继承关系，见图9.6。其中，\lstinline@std::istream@ 是 \lstinline@std::basic_istream@ 类模版的一个实例，定义为 \lstinline@std::basic_istream<char>@；\lstinline@std::ostream@ 是 \lstinline@std::basic_ostream@ 类模版的一个实例，定义为 \lstinline@std::basic_ostream<char>@。\par
 \begin{figure}[htbp]

generalized_parts/10_common_problems_in_inheritance.tex

@@ -4,7 +4,7 @@ \chapter{继承中的常见问题}
     \item 继承关系中的类型转换是怎么进行的？又有什么规则？\par
     \item 多态又是怎么一回事？虚函数到底在做什么？\par
     \item 如果描述基类所需要的成员比描述派生类的还要多，那怎么办？\par
-    \item 多重继承是什么？怎么理解？又有什么用？\par
+    \item 多重继承是什么？怎么理解？又要怎么用？\par
     \item 棱形继承关系中，基类的成员重复了怎么办？\par
 \end{itemize}
 这些问题在实际编程中很常见，所以我们需要好好研究一下，以防将来真的用的时候你突然一拍脑门说：``哎呀，我没学过这玩意。''那就有点麻烦了。\par

generalized_parts/10_common_problems_in_inheritance/03_abstract_base_class_and_pure_virtual_function.tex

@@ -57,15 +57,14 @@ \subsection*{实操：不同的几何图形}
         return rad * 180 / Pi;
     }
     virtual double perimeter()const = 0; //周长，纯虚函数
-    virtual double area()const = 0; //周长，纯虚函数
-    virtual ~Shape() {} //析构，虚函数
+    virtual double area()const = 0; //面积，纯虚函数
 };
 \end{lstlisting}
 这里的 \lstinline@Shape@ 用 \lstinline@struct@ 来定义，这样可以少写一个 \lstinline@public@ 了。\par
 接下来我们就用 \lstinline@Shape@ 派生其它类，如图4.5所示。\par
 \begin{figure}[htbp]
     \centering
-    \includegraphics[width=.8\textwidth]{../images/generalized_parts/10_abstract_shape_class_300.png}
+    \includegraphics[width=.6\textwidth]{../images/generalized_parts/10_abstract_shape_class_300.png}
     \caption{\lstinline@Shape@ 之下派生的各个类}
 \end{figure}
 三角形和圆形的定义很简单，没什么可说的。
@@ -77,8 +76,8 @@ \subsection*{实操：不同的几何图形}
 public:
     Triangle(double a, double b, double c)
         : _a {a}, _b {b}, _c {c} {} //构造函数
-    virtual double perimeter()const { return _a + _b + _c; } //周长
-    virtual double area()const { //面积
+    double perimeter()const { return _a + _b + _c; } //周长
+    double area()const { //面积
         double s {(_a + _b + _c) / 2};
         return std::sqrt(s * (s - _a) * (s - _b) * (s - _c));
     }
@@ -87,8 +86,8 @@ \subsection*{实操：不同的几何图形}
     double _r; //圆的半径
 public:
     Circle(double r) : _r {r} {}
-    virtual double perimeter()const { return 2 * Pi * _r; } //周长
-    virtual double area()const { return Pi * _r * _r; } //面积
+    double perimeter()const { return 2 * Pi * _r; } //周长
+    double area()const { return Pi * _r * _r; } //面积
 };
 \end{lstlisting}
 至于平行四边形这边，就要更复杂一点。我们先把抽象平行四边形基类写出来吧。
@@ -153,7 +152,4 @@ \subsection*{实操：不同的几何图形}
     double area()const { return _a * _a; }
 };
 \end{lstlisting}
-而当调用 \lstinline@Rhombus@ 或者 \lstinline@square@ 的 \lstinline@perimeter()@ 函数时，编译器自然能根据名称查找规则找到 \lstinline@Rhombus_abc::perimeter()@ 来。总之，不必为此操心。\par
-\subsection*{完整代码}
-以下是本例的完整代码。因为所有成员函数都定义在类内了，所以我只提供一个头文件。读者可以自行写源文件并验证其效果。
-\lstinputlisting[caption=\texttt{Header.h}]{code_in_book/10.1/Header.h}\par
+而当调用 \lstinline@Rhombus@ 或者 \lstinline@square@ 的 \lstinline@perimeter()@ 函数时，编译器自然能根据名称查找规则找到 \lstinline@Rhombus_abc::perimeter()@ 来。总而言之，不必为此操心。\par

generalized_parts/10_common_problems_in_inheritance/04_multiple_inheritance.tex

@@ -1,6 +1,6 @@
 \section{多重继承}
 在上一章中，我们看到了C++流输入/输出库中复杂的继承关系。其中的 \lstinline@std::basic_iostream@ 尤为引人注目。你没看错，这个类同时继承自 \lstinline@std::basic_ostream@ 和 \lstinline@std::basic_istream@。这种继承多个基类的操作叫做\textbf{多重继承（Multiple Inheritance）}。\par
-多重继承并不神秘。如果我们把继承视作是单纯的内嵌一个基类对象的话（私有继承是这样做的），那么多重继承就意味着在派生类对象中同时内嵌两个基类对象；如果我们把继承视作是共性成员的代码重用的话（公开继承是这样做的），那么多重继承就意味着派生类同时拥有这两个基类的特怔。\par
+多重继承并不神秘。如果我们把继承视作是单纯的内嵌一个基类对象的话（私有继承是这样做的），那么多重继承就意味着在派生类对象中同时内嵌两个基类对象；如果我们把继承视作是共性成员的代码重用的话（公开继承是这样做的），那么多重继承就意味着派生类同时拥有这两个基类的特征。\par
 以 \lstinline@std::stringstream@ 为例，它继承自 \lstinline@std::iostream@，而 \lstinline@std::iostream@ 多重继承自 \lstinline@std::istream@ 和 \lstinline@std::ostream@，所以它同时拥有 \lstinline@>>@ 和 \lstinline@<<@ 运算符的重载。于是这个类的对象既有输入功能又有输出功能。\par
 \begin{lstlisting}
     std::stringstream ss;
@@ -98,7 +98,7 @@ \subsection*{菱形继承结构的重复成员}
 换句话说，虽然 \lstinline@Derived@ 从根本上来说继承自 \lstinline@Base@，但是因为多重继承的缘故，它实际上有了两份 \lstinline@Base::num@ 成员，一个来自基类 \lstinline@A@，另一个来自基类 \lstinline@B@。\par
 \begin{figure}[htbp]
     \centering
-    \includegraphics[width=.5\textwidth]{../images/generalized_parts/10_diamond_inheritance_300.png}
-    \caption{菱形继承关系下，\lstinline@Derived@ 类内嵌了两份 \lstinline@Base@ 类的对象}
+    \includegraphics[width=.56\textwidth]{../images/generalized_parts/10_diamond_inheritance_300.png}
+    \caption{菱形继承关系下，\lstinline@Derived@ 类内嵌了两份 \lstinline@Base@ 类对象}
 \end{figure}
 在多数情况下，这并不是我们想要的结果，而且还会引发无数的麻烦——比如说，内存空间的浪费，我们明明只需要一份数据，但多重继承为我们搞出了两份数据；再比如说，名称的歧义和冲突，我们不能单纯写成 \lstinline@d.num@，必须写成 \lstinline@d.A::num@ 或 \lstinline@d.B::num@。它们本应该相同的。而在C++中，解决这个问题的对策，就是下一节中要讲到的虚继承。\par