C++中类成员的访问控制
结论
首先给出结论,请看下图,看图说话最容易理解了。
类眼中的自己
类中定义的所有成员,不论是以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 |
所以,在派生类中,对于基类中的各成员的访问权限,我们可以按如下步骤去判断:
- 根据上表,确定基类中各成员在被继承之后访问权限的变化。
- 根据“ 派生类只能看见基类中的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成员
}
从以上实践中可以得出以下结论:
- 类可以访问自身的所有成员,不论是private, protected 还是 public。
- 对象只能访问类的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成员,当然更是可以访问的了,虽然以上例子中并没有验证这一点。
所以,我们可以得出以下结论:
- 友元函数或友元类可以访问类中的所有成员。
另外,关于友元还有一点需要注意。在友元中,只能通过对象来访问声明友元的类成员。
小结
现在,让我们换一个角度,通过以下表格总结一下。
访问控制修饰符 | 类 | 对象 | 友元 |
---|---|---|---|
public | 可见 | 可见 | 可见 |
protected | 可见 | 不可见 | 可见 |
private | 可见 | 不可见 | 可见 |
引入三种继承方式
在C++中,在继承的过程中,有以下三种继承方式,它们分别是:
- public (公有继承)
- protected (保护继承)
- private (私有继承)
这三个关键字与之前的三种访问控制修饰符刚好相同,但在这里,它们有不同的意义。
- 对于public继承,基类中的成员的访问控制修饰符不作任何改动,原样继承到派生类中。
也就是说,基类中的public成员,在被以public方式继承之后,仍然是基类的public成员;基类中的protected成员,仍然是protected成员;基类中的private成员,它仍然是private成员。注意,在继承之后,基类中的private成员对于派生类是不可见的。 - 对于protected继承,基类中的public成员,在被以protected方式继承之后,它变成了基类的protected成员;基类中的protected成员,则仍然是protected成员;基类中的private成员,则仍然是private成员。注意,在继承之后,基类中的private成员对于派生类是不可见的。
- 对于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成员)
}
由以上例子可以看出:
- 基类中的private, protected, public成员,经由public继承之后,在派生类中分别为不可见private, protected,public成员。
- 派生类中不能访问基类的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成员)
}
由以上例子可以看出:
- 基类中的private, protected, public成员,经由protected继承之后,在派生类中分别为不可见private, protected,protected成员。
- 派生类中不能访问基类的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;
}
由以上例子可以看出:
- 基类中的private, protected, public成员,经由private继承之后,在派生类中均不可见。
- 派生类中不能访问基类的private成员,但可以访问基类的private和protected成员。
小结
- 不论何种继承方式,派生类都不能访问基类的private成员,它只能访问基类的public和protected成员。
- 三种继承方式对不同访问控制符修饰的成员的影响如下表所示。
基类中所用访问控制修饰符 | public继承 | protected继承 | private继承 |
---|---|---|---|
public | public | protected | private |
protected | protected | protected | private |
private | private | private | private |
总结
- 友元和类一样,可以访问类的所有成员。
- 对象只能访问类的public成员。
- 派生类只能访问基类的public和protected成员,而不能访问基类的private成员。
- 对于派生出来的类,首先根据继承方式,确定基类各成员在经指定的继承方式继承后的访问控制权限(经继承后基类各成员是变成了public,protected还是private),然后根据第1、2、3点对各成员进行访问。
- 经继承后,基类中的成员会根据继承方式,对各成员的访问控制符进行修改。修改之后,基类中的private成员对派生类不可见。
参考文献
- 郑莉 C++语言程序设计 类的友元 继承方式简介及公有继承 私有继承和保护继承
- 菜鸟教程 C++ 类访问修饰符
C++中类成员的访问控制的更多相关文章
- PHP中类成员的访问控制
类成员访问控制: 1.public 默认的,任何地方都可以访问,类内,类外,子类中 2.protected 受保护的,对外是封闭的,但是类内部和子类可以访问 3.private 私有的,仅限于本类中 ...
- Delphi XE中类成员的访问权限(新增了strict private和strict protected,还有automated)
Delphi XE中类成员的访问权限共提供了6个关键词来用于限定访问权限:public.private.protected.published.automated strict private . s ...
- 鸡啄米:C++编程之十三学习之类与对象,类的声明,成员的访问控制
1. 本次学习鸡啄米课程第13篇,把比较重要的学习记录下来,以敦促自己更好的学习.推荐他们的网址学习:http://www.jizhuomi.com/school/c/97.html 2. 在面向过程 ...
- this、static、main方法、静态代码块、final关键字、Runtime类、Cloneable类、类成员的访问控制权限、异常体系
this表示当前对象,用在方法内部,当某对象调用该方法时,该方法中的this就代表调用该方法的对象: static关键字: 修饰类属性后,该属性就成为该类所有实例的公共属性,修改该属性值,所有的实例的 ...
- Java中类成员变量初始化顺序
一. 定义处默认初始化vs构造函数中初始化 java中类成员变量支持在声明处初始化,也可以在构造函数中初始化,那么这两者有什么区别呢?看下面例子 public class FieldsInit { p ...
- C++中类成员变量在初始化列表中的初始化顺序
引子:我们知道,C++中类成员变量的初始化顺序与其在类中的声明顺序是有关的. 先看代码: class TestClass1 { public: TestClass1() { cout << ...
- C++中类成员使用前需要初始化的重要性
今天写程序的时候,创建了一个结构体: struct BufferObj { char* buf; int bufLen; SOCKADDR_STORAGE addr; int addrLen; str ...
- C++中类成员函数作为回调函数
注:与tr1::function对象结合使用,能获得更好的效果,详情见http://blog.csdn.net/this_capslock/article/details/38564719 回调函数是 ...
- C#中类成员的执行顺序
先进行细分: 类的成员分为:字段.属性.方法.构造方法 成员的修饰符:静态成员.实例成员 层次结构:父类.子类 先不考虑继承关系,执行顺序为: 静态字段静态构造方法实例字段实例构造方法属性和方法是在调 ...
随机推荐
- doxygen+graphviz轻松绘制函数调用图(call graph)
前言 之前的工作环境习惯了使用source insight查看函数分析代码,切换到mac下后改用vscode,发现缺少函数调用关系图生成.跨平台的understand可以很好的解决,但是公司没有购买, ...
- C语言合法标识符(hud2024)
输入方式:先输入一个整型,再循环输入带空格的字符串. 思考:整型用scanf_s()输入.大循环输入字符串前用getchar()函数读取缓冲区的字符.然后,输入带空格的字符串就要用”gets_s()“ ...
- html5拖动监听
在拖动目标上触发事件 (源元素): ondragstart - 用户开始拖动元素时触发 ondrag - 元素正在拖动时触发 ondragend - 用户完成元素拖动后触发 释放目标时触发的事件: o ...
- C#中的any和all
any是判断列表里面是否有哪怕一个: all是判断列表里面是否每一项都包含:
- linux:安装
安装准备 1.虚拟机:VMware® Workstation 12 Pro 2.系统:CentOS-6.5-i386-bin-DVD1.iso 新建虚拟机 网络设置: NAT:配置好后Windows与 ...
- SEPC:使用3D卷积从FPN中提取尺度不变特征,涨点神器 | CVPR 2020
论文提出PConv为对特征金字塔进行3D卷积,配合特定的iBN进行正则化,能够有效地融合尺度间的内在关系,另外,论文提出SEPC,使用可变形卷积来适应实际特征间对应的不规律性,保持尺度均衡.PConv ...
- [JavaWeb基础] 029.OGNL表达式介绍
1.OGNL概述 OGNL,全称为Object-Graph Navigation Language,它是一个功能强大的表达式语言,用来获取和设置Java对象的属性,它旨在提供一个更高的更抽象的层次来对 ...
- python爬取王者荣耀全英雄皮肤
import os import requests url = 'https://pvp.qq.com/web201605/js/herolist.json' herolist = requests. ...
- JAVA中的注释方法
Java的三种注释方法 ①单行注释:使用 // ,其注释内容从//开始到本行结束,比较常用, 快捷键为:Ctrl + / 或者 Ctrl + Shift + C 取消注释:Ctrl + / 或者 ...
- [05]HTML基础之表格标签
1. <table>标签 表格容器,尽量避免用属性书写样式,而是用CSS来表达 border: 数字 //表格边框宽度 2. <caption>标签 表格的标题,一般出现在表格 ...