继承的访问控制

1、单个类的访问控制
单个类的访问控制我们都是知道的，而且在之前的课程中也讲过了：
public 修饰的成员变量 方法 在类的内部 类的外部都能使用。
protected: 修饰的成员变量方法,在类的内部使用 ,在继承的子类中可用 ;其他 类的外部不能被使用。
private: 修饰的成员变量方法 只能在类的内部使用 不能在类的外部。
2、继承权限
不同的继承方式会影响基类成员在派生类中的访问权限。

1) public继承方式
基类中所有 public 成员在派生类中为 public 属性；
基类中所有 protected 成员在派生类中为 protected 属性；
基类中所有 private 成员在派生类中不能使用。

2) protected继承方式
基类中的所有 public 成员在派生类中为 protected 属性；
基类中的所有 protected 成员在派生类中为 protected 属性；
基类中的所有 private 成员在派生类中不能使用。

3) private继承方式
基类中的所有 public 成员在派生类中均为 private 属性；
基类中的所有 protected 成员在派生类中均为 private 属性；
基类中的所有 private 成员在派生类中不能使用。

通过上面的分析可以发现：
1) 基类成员在派生类中的访问权限不得高于继承方式中指定的权限。例如，当继承方式为 protected 时，那么基类成员在派生类中的访问权限最高也为 protected，高于 protected 的会降级为 protected，但低于 protected 不会升级。再如，当继承方式为 public 时，那么基类成员在派生类中的访问权限将保持不变。
也就是说，继承方式中的 public、protected、private 是用来指明基类成员在派生类中的最高访问权限的。
2) 不管继承方式如何，基类中的 private 成员在派生类中始终不能使用（不能在派生类的成员函数中访问或调用）。
3) 如果希望基类的成员能够被派生类继承并且毫无障碍地使用，那么这些成员只能声明为 public 或 protected；只有那些不希望在派生类中使用的成员才声明为 private。

4) 如果希望基类的成员既不向外暴露（不能通过对象访问），还能在派生类中使用，那么只能声明为 protected。
注意，我们这里说的是基类的 private 成员不能在派生类中使用，并没有说基类的 private 成员不能被继承。实际上，基类的 private 成员是能够被继承的，并且（成员变量）会占用派生类对象的内存，它只是在派生类中不可见，导致无法使用罢了。private 成员的这种特性，能够很好的对派生类隐藏基类的实现，以体现面向对象的封装性。
继承的访问权限我们可以通过下面这个案例来巩固一下，相信下面这个案例掌握了，继承的权限访问控制就没有多大问题了。

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
#include <iostream>
using namespace  std;
class Parent
{
public:
  Parent(int var = -1)
  {

  }
public:
  int m_nPub;
protected:
  int m_nPtd;
private:
  int m_nPrt;
};


class Child1:public Parent
{
public:
  int getPub() {return m_nPub;}
  int getPtd() {return m_nPtd;}
  int getPrt() {return m_nPrt;}   // A  基类中的私有成员变量，所以是不能访问的
};

class Child2:protected Parent
{
public:
  int getPub() {return m_nPub;}
  int getPtd() {return m_nPtd;}
  int getPrt() {return m_nPrt;}   // B   基类中的私有成员变量，所以是不能访问的

};

class Child3:private Parent
{
public:
  int getPub() {return m_nPub;}
  int getPtd() {return m_nPtd;}
  int getPrt() {return m_nPrt;}   // C  基类中的私有成员变量，所以是不能访问的

};

int main()
{
  Child1 cd1;
  Child2 cd2;
  Child3 cd3;

  int nVar = 0;
  cd1.m_nPub = nVar;    // D  基类中的公有成员变量，以public方式继承，在类外部是可以访问的
  cd1.m_nPtd = nVar;    // E 基类中的受保护成员变量，以public方式继承，在类外部是不可以访问的。
  nVar = cd1.getPtd();  // F类中的公共的成员方法，在类外部是可以访问的。

  cd2.m_nPub = nVar;    // G 基类中的公共成员变量，以protected方式继承，在类外部是不可以访问的。
  nVar = cd2.getPtd();  // H  类中的公共的成员方法，在类外部是可以访问的。


  cd3.m_nPub = nVar;    // I 基类中的公共的成员变量，以private方式继承，在类外部是不可以访问的。
  nVar = cd3.getPtd();  // J 类中的公共的成员方法，在类外部是可以访问的。

  return 0;
}

最后进行一个小小的总结关于判断能否被访问的方法：
1）看调用语句位置，这句话写在子类的内部、外部
2）看子类如何从父类继承（public、private、protected）
3）看父类中的访问级别（public、private、protected）

最后

以上就是文艺菠萝最近收集整理的关于继承的访问控制的全部内容，更多相关继承内容请搜索靠谱客的其他文章。