---

前言

我发现有时候概念性的东西，理解起来还是很难的，于是本文用简单的几个例子，来说明这三种不同的继承方式，他们之前的区别~

---

一、public继承

• 基类的public和protected成员的访问属性在派生类中保持不变，但基类的private成员不可直接访问。

• 派生类中的成员函数可以直接访问基类中的public和protected成员，但不能直接访问基类的private成员。

• 通过派生类的对象访问从基类继承的成员，只能访问public成员。

  #include

  using namespace std;

  class CFather
  {
  public:
  int m_testA{0};
  protected:
  int m_testB{0};
  private:
  int m_testC{0};
  };

  class CSon: public CFather
  {
  void test()
  {
  m_testA = 1; // 编译正确 ：public 继承后，在内部或者外部都可以访问public成员
  m_testB = 1; // 编译正确 ：public 继承后，在内部可以访问protected成员
  m_testC = 1; // 编译错误 ：无论哪种继承，都无法访问private成员
  }
  };

  int main()
  {
  CSon _test;

  _test.m_testA = 2; // 编译正确 ：public 继承后，在内部或者外部都可以访问public成员
  _test.m_testB = 2; // 编译错误 ：public 继承后，在外部无法访问protected成员
  _test.m_testC = 2; // 编译错误 ：无论哪种继承，都无法访问private成员
  
  system("pause");
  return 0;

  }

---

二、protected继承

• 基类的public和protected成员都以private身份出现在派生类中，但基类的private成员不可直接``访问。

• 派生类中的成员函数可以直接访问基类中的public和protected成员，但不能直接访问基类的private成员。

• 通过派生类的对象不能直接访问从基类继承的任何成员。

  #include

  using namespace std;

  class CFather
  {
  public:
  int m_testA{0};
  protected:
  int m_testB{0};
  private:
  int m_testC{0};
  };

  class CSon: protected CFather
  {
  void test()
  {
  m_testA = 1; // 编译正确 ：protected 继承后，在内部可以访问public成员
  m_testB = 1; // 编译正确 ：protected 继承后，在内部可以访问protected成员
  m_testC = 1; // 编译错误 ：无论哪种继承，都无法访问private成员
  }
  };

  int main()
  {
  CSon _test;

  _test.m_testA = 2; // 编译错误 ：protected 继承后，在外部无法访问public成员
  _test.m_testB = 2; // 编译错误 ：protected 继承后，在外部无法访问protected成员
  _test.m_testC = 2; // 编译错误 ：无论哪种继承，都无法访问private成员
  
  system("pause");
  return 0;

  }

此时，可以这么理解为 派生类 通过 protected继承 基类 之后 ，基类 中的 public变成了protected,其他保持原样。

class CFather
{
protected:// proteced 继承之后public变成了 proteced
    int m_testA{0};
protected:
    int m_testB{0};
private:
    int m_testC{0};
};

---

三、private继承

• 基类的public和protected成员都以private身份出现在派生类中，但基类的private成员不可直接访问。

• 派生类中的成员函数可以直接访问基类中的public和protected成员，但不能直接访问基类的private成员。

• 通过派生类的对象不能直接访问从基类继承的任何成员。

  #include

  using namespace std;

  class CFather
  {
  public:
  int m_testA{0};
  protected:
  int m_testB{0};
  private:
  int m_testC{0};
  };

  class CSon: private CFather
  {
  void test()
  {
  m_testA = 1; // 编译正确 ：private 继承后，在内部可以访问public成员
  m_testB = 1; // 编译正确 ：private 继承后，在内部可以访问protected成员
  m_testC = 1; // 编译错误 ：无论哪种继承，都无法访问private成员
  }
  };

  int main()
  {
  CSon _test;

  _test.m_testA = 2; // 编译错误 ：private 继承后，在外部无法访问public成员
  _test.m_testB = 2; // 编译错误 ：private 继承后，在外部无法访问protected成员
  _test.m_testC = 2; // 编译错误 ：无论哪种继承，都无法访问private成员
  
  system("pause");
  return 0;

  }

此时，可以这么理解为 派生类 通过 private继承 基类 之后 ，基类 中的 public与protected变成了private,其他保持原样。

class CFather
{
private:// private 继承之后public变成了 private
    int m_testA{0};
private:// private 继承之后protected变成了 private
    int m_testB{0};
private:
    int m_testC{0};
};

---

四、三者区别

• public继承方式

  • 基类中所有 public 成员在派生类中为 public 属性；
  • 基类中所有 protected 成员在派生类中为 protected 属性；
  • 基类中所有 private 成员在派生类中不能使用。

• protected继承方式

  • 基类中的所有 public 成员在派生类中为 protected 属性；
  • 基类中的所有 protected 成员在派生类中为 protected 属性；
  • 基类中的所有 private 成员在派生类中不能使用。

• private继承方式

  • 基类中的所有 public 成员在派生类中均为 private 属性；
  • 基类中的所有 protected 成员在派生类中均为 private 属性；
  • 基类中的所有 private 成员在派生类中不能使用。

下表汇总了不同继承方式对不同属性的成员的影响结果

继承方式/基类成员

public成员

protected成员

private成员

public继承

public

protected

不可见

protected继承

protected

protected

不可见

private继承

private

private

不可见

---

五、总结

1.不管继承方式如何，基类中的 private 成员在派生类中始终不能使用（不能在派生类的成员函数中访问或调用）。

2.如果希望基类的成员能够被派生类继承并且毫无障碍地使用，那么这些成员只能声明为 public 或 protected；只有那些不希望在派生类中使用的成员才声明为 private。

3.如果希望基类的成员既不向外暴露（不能通过对象访问），还能在派生类中使用，那么只能声明为 protected。

4.基类成员在派生类中的访问权限不得高于继承方式中指定的权限。例如，当继承方式为 protected 时，那么基类成员在派生类中的访问权限最高也为 protected，高于 protected 的会降级为 protected，但低于 protected 不会升级。再如，当继承方式为 public 时，那么基类成员在派生类中的访问权限将保持不变。

---

后话

我们这里说的是基类的 private 成员不能在派生类中使用，并没有说基类的 private 成员不能被继承。实际上，基类的 private 成员是能够被继承的，并且（成员变量）会占用派生类对象的内存，它只是在派生类中不可见，导致无法使用罢了。private 成员的这种特性，能够很好的对派生类隐藏基类的实现，以体现面向对象的封装性。由于 private 和 protected 继承方式会改变基类成员在派生类中的访问权限，导致继承关系复杂，所以实际开发中我们一般使用 public。