结论

首先给出结论，请看下图，看图说话最容易理解了。

类眼中的自己

类中定义的所有成员，不论是以public, protected还是private修饰，对类自身而言，它们都是可见的。

对象眼中的类

站在类的对象的角度去观察类，这时，只有类中的public成员是可见的。而其中的protected和private成员对对象而言，是不可见的。

友元眼中的类

站在友元的角度，类中所有的成员，不论是以public, protected还是private修饰，对友元而言，它们都是可见的。

派生类眼中的基类

派生类只能看见基类中的public和protected成员。而基类中的private成员，对于派生类而言，是不可见的。有一点必须注意，这里的public, protected和private均是指基类在被继承之后所呈现出来的成员访问权限。

下表展示了不同的继承方式，对基类中各成员访问权限的影响。

基类中所用访问控制修饰符 public继承 protected继承 private继承
public public protected private
protected protected protected private
private private private private

所以，在派生类中，对于基类中的各成员的访问权限，我们可以按如下步骤去判断：

  1. 根据上表，确定基类中各成员在被继承之后访问权限的变化。
  2. 根据“ 派生类只能看见基类中的public和protected成员” 这一点来确定哪些基类成员可以被访问。

好了，到这里为止，结论就全部说完了。

接下来全是对结论的验证，所以，无需从头至尾浏览，请有针对性的选择查看。

引入三种访问控制符

C++中，存在三种访问控制修饰符，它们分别是：

  • public // 公有成员
  • protected // 保护成员
  • private // 私有成员

术语

为了使文章容易理解，我们对以下术语作出说明：

  • 对象： 与类相对，对象是类的实例。
  • 派生类：与基类相对，派生类就是子类。
  • 继承：继承与派生是一个意思。继承偏重指出此过程中不变的部分，而派生的意思则更偏向于在原有基础上所新增加的部分。
  • 成员：类中成员变量和成员函数的统称。

实践1--对象的访问权限

在以下的例子中，我们创建了一个简单的类。

下面，我们就来探究一下，对于该类中被不同访问控制修饰符修饰的成员，它们对于该类的对象都有什么样的访问权限。

#include <iostream>

using namespace std;

class CBase

{

private:

	int a_base_private;

protected:

	int b_base_protected;

public:

	int c_base_public;

public:

	CBase(){a_base_private = 1; b_base_protected = 2; c_base_public = 3;}

	~CBase(){}

	int getA() const {return a_base_private;}		// OK, 类可以访问自身的所有成员

	int getB() const {return b_base_protected;}		// OK, 类可以访问自身的所有成员

	int getC() const {return c_base_public;}		// OK, 类可以访问自身的所有成员

};

int main()

{

	int tmp;

	CBase baseObj;

	//baseObj.a_base_private = 1;			// KO, 对象不能访问类的private成员

	//baseObj.b_base_protected = 1;			// KO, 对象不能访问类的protected成员

	baseObj.c_base_public = 1;				// OK, 对象可以访问类的public成员

	tmp = baseObj.getA();		// OK, 对象可以访问类的public成员

	tmp = baseObj.getB();		// OK, 对象可以访问类的public成员

	tmp = baseObj.getC();		// OK, 对象可以访问类的public成员

}

从以上实践中可以得出以下结论：

  1. 类可以访问自身的所有成员，不论是private, protected 还是 public。
  2. 对象只能访问类的public成员。

实践2--友元的访问权限

在以上例子的基础上，让我们来考虑一下，对于该类中被不同访问控制修饰符修饰的成员，该类的友元函数和友元类对这些成员都有什么样的访问权限。

#include <iostream>

using namespace std;

class CBase;

class CFriend;

void ClearBaseA(CBase &obj);

class CBase

{

friend 	CFriend;							// 声明CFriend为自己的友元类

friend 	void ClearBaseB(CBase &obj);		// 声明ClearBaseA为自己的友元函数

private:

	int a_base_private;

protected:

	int b_base_protected;

public:

	int c_base_public;

public:

	CBase(){a_base_private = 1; b_base_protected = 2; c_base_public = 3;}

	~CBase(){}

	int getA() const {return a_base_private;}		// OK, 类可以访问自身的所有成员

	int getB() const {return b_base_protected;}		// OK, 类可以访问自身的所有成员

	int getC() const {return c_base_public;}		// OK, 类可以访问自身的所有成员

};

class CFriend

{

private:

	CBase obj;

public:

	CFriend(){}

	~CFriend(){}

	int setBaseA(int f) {obj.a_base_private = f;}		// OK, 在友元类中，可以访问Base类的私有成员

	int getBaseA() const {return obj.getA();}

};

void ClearBaseB(CBase &obj)

{

	obj.b_base_protected = 0;			// OK, 在友元函数中，可以访问Base类的保护成员

}

int main()

{

	int tmp;

	CBase baseObj;

	CFriend friendObj;

	cout << baseObj.getB() << endl;		// 通过构造函数初始化为2

	ClearBaseB(baseObj);

	cout << baseObj.getB() << endl;		// 被友元函数给清0了

	cout << friendObj.getBaseA() << endl;	// 通过构造函数初始化为1

	friendObj.setBaseA(7);

	cout << friendObj.getBaseA() << endl;	// 被友元类给设置为了7

}

由上例中可以看出，友元可以访问类中的private和protected成员，对于public成员，当然更是可以访问的了，虽然以上例子中并没有验证这一点。

所以，我们可以得出以下结论：

  1. 友元函数或友元类可以访问类中的所有成员。

    另外，关于友元还有一点需要注意。在友元中，只能通过对象来访问声明友元的类成员。

小结

现在，让我们换一个角度，通过以下表格总结一下。

访问控制修饰符 类 对象 友元
public 可见 可见 可见
protected 可见 不可见 可见
private 可见 不可见 可见

引入三种继承方式

在C++中，在继承的过程中，有以下三种继承方式，它们分别是：

  • public (公有继承)
  • protected (保护继承)
  • private (私有继承)

    这三个关键字与之前的三种访问控制修饰符刚好相同，但在这里，它们有不同的意义。
  1. 对于public继承，基类中的成员的访问控制修饰符不作任何改动，原样继承到派生类中。

    也就是说，基类中的public成员，在被以public方式继承之后，仍然是基类的public成员；基类中的protected成员，仍然是protected成员；基类中的private成员，它仍然是private成员。注意，在继承之后，基类中的private成员对于派生类是不可见的。
  2. 对于protected继承，基类中的public成员，在被以protected方式继承之后，它变成了基类的protected成员；基类中的protected成员，则仍然是protected成员；基类中的private成员，则仍然是private成员。注意，在继承之后，基类中的private成员对于派生类是不可见的。
  3. 对于private继承，基类中的public和protected和private成员，在被以private方式继承之后，在基类中均成为了private成员；而基类中的private成员，对派生类不可见。

public继承方式

在第一个例子的基础之上，我们通过public方式继承出一个新的派生类。

#include <iostream>

using namespace std;

class CBase

{

private:

	int a_base_private;

protected:

	int b_base_protected;

public:

	int c_base_public;

public:

	CBase(){a_base_private = 1; b_base_protected = 2; c_base_public = 3;}

	~CBase(){}

	int getA() const {return a_base_private;}		// OK, 类可以访问自身的所有成员

	int getB() const {return b_base_protected;}		// OK, 类可以访问自身的所有成员

	int getC() const {return c_base_public;}		// OK, 类可以访问自身的所有成员

};

class CDerived:public CBase

{

private:

	int x_derived_private;

protected:

	int y_derived_protected;

public:

	int z_derived_private;

public:

	CDerived(){x_derived_private = 4; y_derived_protected = 5; z_derived_private = 6;}

	~CDerived(){}

	//void setBaseA(int t){a_base_private = t;}		// KO, 派生类中不能访问基类的private成员

	void setBaseB(int t){b_base_protected = t;}		// OK, 派生类中可以访问基类的protected成员

	void setBaseC(int t){c_base_public = t;}		// OK, 派生类中可以访问基类的public成员	

	int getX() const {return x_derived_private;}

	int getY() const {return y_derived_protected;}

	int getZ() const {return z_derived_private;}

};

int main()

{

	CDerived derivedObj;

	//derivedObj.a_base_private = 1;			// KO, 基类中由private修饰的a_base_private，对派生类是不可见的，即使在派生类中都不能访问，更别提派生类对象了。

	//derivedObj.b_base_protected = 1;			// KO, 对象不能访问类的protected成员(public方式继承的protected成员，在派生类中仍为protected成员)

	derivedObj.c_base_public = 1;				// OK, 对象可以访问类的public成员(public方式继承的public成员，在派生类中仍为public成员)

	cout << derivedObj.getA() << endl;		// OK, 对象可以访问类的public成员(public方式继承的public成员，在派生类中仍为public成员)

	derivedObj.setBaseB(8);					// OK, 对象可以访问类的public成员

	cout << derivedObj.getB() << endl;		// OK, 对象可以访问类的public成员(public方式继承的public成员，在派生类中仍为public成员)

	derivedObj.setBaseC(9);					// OK, 对象可以访问类的public成员

	cout << derivedObj.getC() << endl;		// OK, 对象可以访问类的public成员(public方式继承的public成员，在派生类中仍为public成员)

}

由以上例子可以看出：

  1. 基类中的private, protected, public成员，经由public继承之后，在派生类中分别为不可见private, protected,public成员。
  2. 派生类中不能访问基类的private成员，但可以访问基类的private和protected成员。

protected继承方式

在第一个例子的基础之上，我们通过protected方式继承出一个新的派生类。

#include <iostream>

using namespace std;

class CBase

{

private:

	int a_base_private;

protected:

	int b_base_protected;

public:

	int c_base_public;

public:

	CBase(){a_base_private = 1; b_base_protected = 2; c_base_public = 3;}

	~CBase(){}

	int getA() const {return a_base_private;}		// OK, 类可以访问自身的所有成员

	int getB() const {return b_base_protected;}		// OK, 类可以访问自身的所有成员

	int getC() const {return c_base_public;}		// OK, 类可以访问自身的所有成员

};

class CDerived:protected CBase

{

private:

	int x_derived_private;

protected:

	int y_derived_protected;

public:

	int z_derived_private;

public:

	CDerived(){x_derived_private = 4; y_derived_protected = 5; z_derived_private = 6;}

	~CDerived(){}

	//void setBaseA(int t){a_base_private = t;}		// KO, 派生类中不能访问基类的private成员

	void setBaseB(int t){b_base_protected = t;}		// OK, 派生类中可以访问基类的protected成员

	void setBaseC(int t){c_base_public = t;}		// OK, 派生类中可以访问基类的public成员

	int getX() const {return x_derived_private;}	// OK, 类可以访问自身的所有成员

	int getY() const {return y_derived_protected;}	// OK, 类可以访问自身的所有成员

	int getZ() const {return z_derived_private;}	// OK, 类可以访问自身的所有成员

};

int main()

{

	CDerived derivedObj;

	//derivedObj.a_base_private = 1;			// KO, 对象不能访问类的private成员(protected方式继承的private成员，在派生类中不可见)

	//derivedObj.b_base_protected = 1;			// KO, 对象不能访问类的protected成员(protected方式继承的protected成员，在派生类中仍为protected成员)

	//derivedObj.c_base_public = 1;				// KO, 对象不可以访问类的protected成员(protected方式继承的public成员，在派生类中成为protected成员)

	//cout << derivedObj.getA() << endl;		// KO, 对象不可以访问类的protected成员(protected方式继承的public成员，在派生类中成为protected成员)

	//cout << derivedObj.getB() << endl;		// KO, 对象不可以访问类的protected成员(protected方式继承的public成员，在派生类中成为protected成员)

	//cout << derivedObj.getC() << endl;		// KO, 对象不可以访问类的protected成员(protected方式继承的public成员，在派生类中成为protected成员)

}

由以上例子可以看出：

  1. 基类中的private, protected, public成员，经由protected继承之后，在派生类中分别为不可见private, protected,protected成员。
  2. 派生类中不能访问基类的private成员，但可以访问基类的private和protected成员。

private继承方式

在第一个例子的基础之上，我们通过private方式继承出一个新的派生类。

#include <iostream>

using namespace std;

class CBase

{

private:

	int a_base_private;

protected:

	int b_base_protected;

public:

	int c_base_public;

public:

	CBase(){a_base_private = 1; b_base_protected = 2; c_base_public = 3;}

	~CBase(){}

	int getA() const {return a_base_private;}		// OK, 类可以访问自身的所有成员

	int getB() const {return b_base_protected;}		// OK, 类可以访问自身的所有成员

	int getC() const {return c_base_public;}		// OK, 类可以访问自身的所有成员

};

class CDerived:private CBase

{

private:

	int x_derived_private;

protected:

	int y_derived_protected;

public:

	int z_derived_private;

public:

	CDerived(){x_derived_private = 4; y_derived_protected = 5; z_derived_private = 6;}

	~CDerived(){}

	//void setBaseA(int t){a_base_private = t;}		// KO, 派生类中不能访问基类的private成员，因为其在派生类中不可见

	void setBaseB(int t){b_base_protected = t;}		// OK, 派生类中可以访问基类的protected成员

	void setBaseC(int t){c_base_public = t;}		// OK, 派生类中可以访问基类的public成员

	int getX() const {return x_derived_private;}	// OK, 类可以访问自身的所有成员

	int getY() const {return y_derived_protected;}	// OK, 类可以访问自身的所有成员

	int getZ() const {return z_derived_private;}	// OK, 类可以访问自身的所有成员

};

int main()

{

	CDerived derivedObj;

	//derivedObj.a_base_private = 1;			// KO, (private方式继承的private成员，在派生类中不可见)

	//derivedObj.b_base_protected = 1;			// KO, (private方式继承的protected成员，在派生类中不可见)

	//derivedObj.c_base_public = 1;				// KO, (private方式继承的public成员，在派生类中成为不可见)

	//cout << derivedObj.getA() << endl;		// KO, (private方式继承的public成员，在派生类中不可见)

	//cout << derivedObj.getB() << endl;		// KO, (private方式继承的public成员，在派生类中不可见)

	//cout << derivedObj.getC() << endl;		// KO, (private方式继承的public成员，在派生类中不可见)

	cout << derivedObj.getX() << endl;

	cout << derivedObj.getY() << endl;

	cout << derivedObj.getZ() << endl;

}

由以上例子可以看出：

  1. 基类中的private, protected, public成员，经由private继承之后，在派生类中均不可见。
  2. 派生类中不能访问基类的private成员，但可以访问基类的private和protected成员。

小结

  • 不论何种继承方式，派生类都不能访问基类的private成员，它只能访问基类的public和protected成员。
  • 三种继承方式对不同访问控制符修饰的成员的影响如下表所示。
基类中所用访问控制修饰符 public继承 protected继承 private继承
public public protected private
protected protected protected private
private private private private

总结

  1. 友元和类一样，可以访问类的所有成员。
  2. 对象只能访问类的public成员。
  3. 派生类只能访问基类的public和protected成员，而不能访问基类的private成员。
  4. 对于派生出来的类，首先根据继承方式，确定基类各成员在经指定的继承方式继承后的访问控制权限(经继承后基类各成员是变成了public,protected还是private),然后根据第1、2、3点对各成员进行访问。
  5. 经继承后，基类中的成员会根据继承方式，对各成员的访问控制符进行修改。修改之后，基类中的private成员对派生类不可见。

参考文献

最新文章

  1. 百度前端技术学院2015JavaScript基础部分-BOM
  2. PHP 文件下载流程
  3. grunt集成自动启动
  4. BZOJ4260: Codechef REBXOR
  5. 图的最短路算法 Floyd
  6. C++函数传指针和传引用的区别
  7. sql时间段算法
  8. Android SQLite ORM框架greenDAO在Android Studio中的配置与使用
  9. django-rest-framework 快速开始
  10. 兼容ie浏览器的placeholder的几种方法
  11. 25.django Model
  12. Git 配置用户名、密码
  13. [ 随手记 2 ] C/C++ 数组/指针/传数组到函数/指针数组/数组指针
  14. shell执行Python并传参
  15. 北航学堂Android客户端Beta阶段测试报告
  16. Magpie
  17. Emmm，从删库到跑路系列之.......Root权限的重要性
  18. 坊间流传着的关于谷歌大牛Jeff Dean的传说
  19. 大数据入门：Hadoop安装、环境配置及检测
  20. bzoj3463【COCI2012】 Inspector

热门文章

  1. SWPU邮件登录界面的仿写（第二次作业）
  2. python3.x 基础三：文件IO
  3. dij+DP
  4. win-sudo插件解决Git bash 执行脚本报错问题 bash: sudo: command not found
  5. 你还不懂 Tomcat 的优化吗？
  6. Robot Framework（3）- 基本概念
  7. RabbitMQ镜像集群搭建
  8. java方式实现插入排序
  9. Spring Cloud Stream微服务消息框架
  10. 手把手教你学numpy，从此数据处理不再慌【三】