四、C++ 类的继承

一、引言

1.1 类成员的三种类型

我们知道，在类中一共有三种类型，分别为public，private和protected，默认为private，在结构中，默认是public

1.2 访问控制和继承

可见，在一个类中，只有类内的成员才可以访问private

二、类的继承

2.1 格式

继承允许我们依据一个类来创建一个类，这个已有的类称为基类，新创建的类称为派生类

class derived-class: access-specifier base-class1,access-specifier class2 ......
1

2.2 继承类型

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

  #include 
  
  using namespace std;
  
  // 定义基类
  class Student
  {
  public:
      char name;
  
  private:
      int age;
  
  protected:
      double height;
  };
  //
  // public继承:可以访问public,portected
  // public-->public
  // protected-->protected
  class Public : public Student
  {
  public:
      void set_name(char name);
      char get_name(void);
  };
  
  void Public::set_name(char na)
  {
      name = na;
  }
  
  char Public::get_name()
  {
      return name;
  }
  //
  
  // private继承：可以访问public,portected
  // public-->private
  // protected-->private
  class Private : private Student
  {
  public:
      void set_name(char name);
      char get_name(void);
  };
  
  void Private::set_name(char na)
  {
      name = na;
  }
  
  char Private::get_name()
  {
      return name;
  }
  /
  // protected继承可以访问public,portected
  // public-->portected
  // protected-->portected
  class Protect : protected Student
  {
  public:
      void set_height(double hei);
      double get_height(void);
  
  };
  
  void Protect::set_height(double hei){
      height = hei;
  }
  
  double Protect::get_height(void){
      return height;
  }
  
  ///
  int main()
  {
      Public student1;
      student1.set_name('a');
      cout << "name of student1:" << student1.get_name() << endl;
  
      Private student2;
      student2.set_name('b');
      cout << "name of student2:" << student2.get_name() << endl;
  
      Protect student3;
      student3.set_height(30.0);
      cout<<"height of student3:"<< student3.get_height()<<endl;
  
  }
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68
  69
  70
  71
  72
  73
  74
  75
  76
  77
  78
  79
  80
  81
  82
  83
  84
  85
  86
  87
  88
  89
  90
  91
  92
  93

• 运行结果：

  name of student1:a
  name of student2:b
  height of student3:30
  1
  2
  3

三、多继承

有时候，一个派生类可以从多个基类中继承，这种继承方式称为多继承

• 格式：

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

• 代码实现：

  #include 
  
  using namespace std;
  
  // 基类1
  class Shape
  {
  public:
      void set(double w, double h);
  
  protected:
      double height;
      double weight;
  };
  
  void Shape::set(double w, double h)
  {
      height = h;
      weight = w;
  }
  
  // 基类2
  
  class Cost
  {
  public:
      double cost(double area);
  };
  
  double Cost::cost(double area)
  {
      return area * 100;
  }
  // 派生类
  class Rectangle : public Shape, public Cost
  {
  public:
      double get_area();
  };
  
  double Rectangle::get_area()
  {
      return height * weight;
  }
  
  int main()
  {
      Rectangle rec;
      rec.set(20.333, 2.22323);
      double area = rec.get_area();
      cout << rec.cost(area) << endl;
      return 0;
  }
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54