C++语法 继承与多态 & 虚函数

继承与多态听起来挺高级的，其实还挺简单的。

---

一、C++ 继承

面向对象程序设计中最重要的一个概念是继承。

继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。

这样做，也达到了重用代码功能和提高执行效率的效果。

当创建一个类时，我们不需要重新编写新的数据成员和成员函数

只需指定新建的类继承了一个已有的类的成员即可。

这个已有的类称为基类，新建的类称为派生类。

继承代表了 A is a (what) B 的关系。例如，哺乳动物是动物，狗是哺乳动物，因此，狗是动物，等等。

用代码表示上图：

// 基类
class Animal {
    // eat() 函数
    // sleep() 函数
};


//派生类
class Dog : public Animal {
    // bark() 函数
};

1. 基类 & 派生类

一个类可以派生自多个类，这意味着，它可以从多个基类继承数据和函数。定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名，形式如下：

class derived-class: access-specifier base-class

其中，访问修饰符 access-specifier 是 public、protected 或 private 其中的一个

base-class 是之前定义过的某个类的名称。

如果未使用访问修饰符 access-specifier，则默认为 private，详见下文 3.继承类型。

假设有一个基类 Shape，Rectangle 是它的派生类，如下所示：

#include <iostream>
 
using namespace std;
 
// 基类
class Shape 
{
   public:
      void setWidth(int w)
      {
         width = w;
      }
      void setHeight(int h)
      {
         height = h;
      }
   protected:
      int width;
      int height;
};
 
// 派生类
class Rectangle: public Shape
{
   public:
      int getArea()
      { 
         return (width * height); 
      }
};
 
int main(void)
{
   Rectangle Rect;
 
   Rect.setWidth(5);
   Rect.setHeight(7);
 
   // 输出对象的面积
   cout << "Total area: " << Rect.getArea() << endl; // 会输出 Total area: 35
 
   return 0;
}

2. 访问控制和继承

派生类可以访问基类中所有的非私有成员。

因此基类成员如果不想被派生类的成员函数访问，则应在基类中声明为 private。

我们可以根据访问权限总结出不同的访问类型，如下所示：

一个派生类继承了所有的基类方法，但下列情况除外：

• 基类的构造函数、析构函数和拷贝构造函数。
• 基类的重载运算符。
• 基类的友元函数。

3. 继承类型

当一个类派生自基类，该基类可以被继承为 public、protected 或 private 几种类型。

继承类型是通过上面讲解的访问修饰符 access-specifier 来指定的。

我们几乎不使用 protected 或 private 继承，通常使用 public 继承。

当使用不同类型的继承时，遵循以下几个规则：

• 公有继承（public）：当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。
• 保护继承（protected）： 当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。
• 私有继承（private）：当一个类派生自私有基类时，基类的公有和保护成员将成为派生类的私有成员。

4. 多继承

多继承即一个子类可以有多个父类，它继承了多个父类的特性。

C++ 类可以从多个类继承成员，语法如下：

class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…
{
	<派生类类体>
};

其中，访问修饰符继承方式是 public、protected 或 private 其中的一个，

用来修饰每个基类，各个基类之间用逗号分隔，如上所示。现在让我们一起看看下面的实例：

#include <iostream>
 
using namespace std;
 
// 基类 Shape
class Shape 
{
   public:
      void setWidth(int w)
      {
         width = w;
      }
      void setHeight(int h)
      {
         height = h;
      }
   protected:
      int width;
      int height;
};
 
// 基类 PaintCost
class PaintCost 
{
   public:
      int getCost(int area)
      {
         return area * 70;
      }
};
 
// 派生类
class Rectangle: public Shape, public PaintCost
{
   public:
      int getArea()
      { 
         return (width * height); 
      }
};
 
int main(void)
{
   Rectangle Rect;
   int area;
 
   Rect.setWidth(5);
   Rect.setHeight(7);
 
   area = Rect.getArea();
   
   // 输出对象的面积
   cout << "Total area: " << Rect.getArea() << endl;
 
   // 输出总花费
   cout << "Total paint cost: $" << Rect.getCost(area) << endl;
 
   return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

Total area: 35
Total paint cost: $2450

---

二、C++ 多态

多态按字面的意思就是多种形态。

当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。

C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。

参考下面的实例

#include <iostream> 
using namespace std;
 
class Shape {
   protected:
      int width, height;
   public:
      Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      int area()
      {
         cout << "Parent class area :" <<endl;
         return 0;
      }
};
class Rectangle: public Shape{
   public:
      Rectangle( int a=0, int b=0):Shape(a, b) { }
      int area ()
      { 
         cout << "Rectangle class area :" <<endl;
         return (width * height); 
      }
};
class Triangle: public Shape{
   public:
      Triangle( int a=0, int b=0):Shape(a, b) { }
      int area ()
      { 
         cout << "Triangle class area :" <<endl;
         return (width * height / 2); 
      }
};
// 程序的主函数
int main( )
{
   Shape *shape;
   Rectangle rec(10,7);
   Triangle  tri(10,5);
 
   // 存储矩形的地址
   shape = &rec;
   // 调用矩形的求面积函数 area
   shape->area();
 
   // 存储三角形的地址
   shape = &tri;
   // 调用三角形的求面积函数 area
   shape->area();
   
   return 0;
}

有趣的是，输出的结果是

Parent class area :
Parent class area :

导致错误输出的原因是，调用函数 area() 被编译器设置为基类中的版本

这就是所谓的静态多态，或静态链接，即函数调用在程序执行前就准备好了。

有时候这也被称为早绑定，因为 area() 函数在程序编译期间就已经设置好了。

但现在，让我们对程序稍作修改，在 Shape 类中，area() 的声明前放置关键字 virtual，如下所示：

class Shape {
   protected:
      int width, height;
   public:
      Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      virtual int area() // 通过定义虚函数实现动态链接
      {
         cout << "Parent class area :" <<endl;
         return 0;
      }
};

修改后，当编译和执行前面的实例代码时，它会产生以下结果：

Rectangle class area :
Triangle class area :

此时，编译器看的是指针的内容，而不是它的类型。

因此，由于 tri 和 rec 类的对象的地址存储在 *shape 中，所以会调用各自的 area() 函数。

在实例中，每个子类都有一个函数 area() 的独立实现。这就是多态的一般使用方式。

有了多态，您可以有多个不同的类，都带有同一个名称但具有不同实现的函数，函数的参数甚至可以是相同的。

---

三、虚函数

上文的注释中提到了虚函数。

虚函数 是在基类中使用关键字 virtual 声明的函数。

在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数。

我们想要的是在程序中任意点可以根据所调用的对象类型来选择调用的函数

这种操作被称为动态链接，或后期绑定。

再举一个例子，比如下面这种情况：（即环状继承）

class A{......};
class B: public A{......};
class C: public A{......};
class D: public B, public C{.....};

如下图所示，这样定义会导致 C++ 创建两个共同基类的副本

为了解决上面的问题，我们可以将 B,C 虚继承自 A ，如下

class A{......};
class B: virtual public A{......};
class C: virtual public A{......};
class D: public B, public C{.....};

实际上 B,C 原本在定义时，自动分配了一块内存空间以存储基类 A 的变量

而我们添加 virtual 关键字阻止了这一操作，让编译器先创建一个虚表

等到下面的 D 定义完后，从下往上一路找上来，这就是所谓的后期绑定，是不是很形象？

1. 纯虚函数

我们可能想要在基类中定义虚函数，以便在派生类中重新定义该函数更好地适用于对象

但是在基类中又不能对虚函数给出有意义的实现，这个时候就会用到纯虚函数。

我们可以把基类中的虚函数 area() 改写如下：

class Shape {
   protected:
      int width, height;
   public:
      Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      // pure virtual function
      virtual int area() = 0;
};

=0 告诉编译器，函数没有主体，上面的虚函数是纯虚函数。

---

网上找的一段话：

定义一个函数为虚函数，不代表函数为不被实现的函数。

因为定义他为虚函数是为了允许用基类的指针来调用子类的这个函数。

定义一个函数为纯虚函数，才代表函数没有被实现。

因为定义纯虚函数是为了实现一个接口，起到一个规范的作用，规范继承这个类的程序员必须实现这个函数。

---

参考文献：

[1] https://www.runoob.com/cplusplus/cpp-polymorphism.html

[2] https://www.runoob.com/cplusplus/cpp-inheritance.html

[3] https://zhuanlan.zhihu.com/p/157102200