C++继承详细介绍

C++继承是非常重要的面向对象编程（OOP）概念之一，它允许派生类（子类）继承基类（父类）的特性。通过继承，子类能够重复利用基类的属性和方法，并且可以根据需要添加新的属性和方法。接下来我们将详细介绍C++继承的概念及其相关特性。

基本语法

class BaseClass {
  // 访问说明符
  public:
    int basePublicVar;
  protected:
    int baseProtectedVar;
  private:
    int basePrivateVar;
};

class DerivedClass : accessSpecifier BaseClass {
  // 访问说明符
  public:
    int derivedPublicVar;
  protected:
    int derivedProtectedVar;
  private:
    int derivedPrivateVar;
};

以上是定义派生类的基本语法。在继承中会使用到访问说明符（access specifier）public、protected、private，它们分别用来描述从基类中继承下来的成员函数或成员变量的访问权限，其用法与基类中的使用相同。派生类可以访问其从基类继承而来的公有成员，并使用这些成员，而其保护成员和私有成员则不可访问。

继承类型

公有继承

公有（public）继承是派生类可以访问基类公有成员的一种继承类型。公有继承是最常用的继承类型之一，它在实现“是一个(is-a)”关系时非常有用。

// 定义基类Shape
class Shape {
  public:
    int getArea() {
      return 0;
    }
};

// 定义派生类Rectangle
class Rectangle: public Shape {
  public:
    int width;
    int height;
    int getArea() {
      return (width * height);
    }
};

int main() {
  Rectangle Rect;
  Rect.width = 5;
  Rect.height = 7;
  int area = Rect.getArea();
  cout << "Total area: " << area << endl;
  return 0;
}

上述代码中，Rectangle类通过公有继承来继承Shape类中的getArea()函数，同时也可以定义自身新的成员。

保护继承

保护（protected）继承是一种继承方式，基类中的所有公共成员和保护成员都在派生类中变成了protected，派生类中新增成员的访问权限同样是protected。

class Shape {
  protected:
    int width;
    int height;
  public:
    void setWidth(int w) {
        width = w;
    }
    void setHeight(int h) {
        height = h;
    }
};

class Rectangle: protected Shape {
  public:
    int getArea() {
        return (width * height);
    }
    void setWidth(int w) {
        width = w;
    }
    void setHeight(int h) {
        height = h;
    }
};

int main() {
  Rectangle Rect;
  Rect.setWidth(5);
  Rect.setHeight(7);
  int area = Rect.getArea();
  cout << "Total area: " << area << endl;
  return 0;
}

私有继承

私有（private）继承是一种继承方式，基类中所有公共成员和保护成员都在派生类中变成了私有成员，私有成员只能在派生类的内部访问，不能从派生类外部进行访问。

class Shape {
  private:
    int width;
    int height;
  public:
    void setWidth(int w) {
        width = w;
    }
    void setHeight(int h) {
        height = h;
    }
};

class Rectangle: private Shape {
  public:
    int getArea() {
        return (width * height);
    }
    void setWidth(int w) {
        width = w;
    }
    void setHeight(int h) {
        height = h;
    }
};

int main() {
  Rectangle Rect;
  Rect.setWidth(5);
  Rect.setHeight(7);
  int area = Rect.getArea(); // 将报错
  cout << "Total area: " << area << endl;
  return 0;
}

多重继承

多重继承（multiple Inheritance）指一个类可以同时从多个基类那里继承信息，是C++面向对象编程的一个重要特性。多重继承的基本语法如下：

class Derived_Class: accessSpecifier Base_Class1, accessSpecifier Base_Class2 {
  // 类成员
};

其中Base_Class1和Base_Class2是两个基类，Derived_Class是一个派生类，accessSpecifier用于定义派生类成员访问的属性。同时使用逗号分隔两个基类。

以下是一个多重继承示例：

class Shape {
  public:
    void setWidth(int w) {
        width = w;
    }
    void setHeight(int h) {
        height = h;
    }
  protected:
    int width;
    int height;
};

class PaintCost {
  public:
    int getCost(int area) {
        return area * 70;
    }
};

class Rectangle: public Shape, public PaintCost {
  public:
    int getArea() {
        return (width * height);
    }
};

int main() {
  Rectangle Rect;
  Rect.setWidth(5);
  Rect.setHeight(7);
  int area = Rect.getArea();
  cout << "Total area: " << area << endl;
  cout << "Total paint cost: $" << Rect.getCost(area) << endl;
  return 0;
}

虚拟继承

虚拟继承（Virtual Inheritance）是多重继承的一种特殊方式，虚拟继承解决了多继承中出现的“菱形继承”问题，所引起的“二义性”的问题。

以下是一个虚拟继承的示例：

#include <iostream>
using namespace std;

class Animal {
 public:
  void speak() {
    cout << "Animal speaks" << endl;
  }
};

class Mammal: virtual public Animal { };

class WingedAnimal: virtual public Animal { };

class Bat: public Mammal, public WingedAnimal { };

int main() {
  Bat b1;
  b1.speak();
  return 0;
}

总结

C++中的继承是一个非常重要的面向对象编程概念，通过继承可以使子类重复利用基类的代码，从而减少代码的重复。在继承时需要注意访问权限以及多重继承可能引起的“菱形继承”问题。虚拟继承通过虚拟继承解决了这个问题。