[C++] OOP - Access Control and Class Scope
Access Control And Inheritance
Protected Member
Like private, protected members are unaccessible to users of the class
Like public, protected members are accessible to members and friends of classes derived from this class.
Members and friends of a derived class can access the protected members only on the base class that are embeded inside the derived type object; they have no special access to a ordinary object of the base class.
class Base{
protected:
int prot_item;
};
class Sneaky : public Base{
friend void clobber(Sneeky &);
friend void clobber(Base &);
int j;
};
void clobber(Sneaky & s) { s.prote_item =;} // ok
// error: clobber cannot access the protect member in Base;
void clobber(Base & b) { b.prot_item = ;}
public, private and protect inheritance
class Base{
public:
void pub_mem();
protected:
int prot_mem;
private:
char priv_mem;
} struct Pub_Derv : public Base{
// ok. derived class can access protected members
int f() { return prot_mem; }
// error. private members are inaccessible to derived class
char g() { return priv_mem; }
} struct Priv_Derv : private Base{
// private derivation do not affect access in the derived class
int f1() { return prot_mem; } // ok
char g2() {return priv_mem; } // error
}
The derivation access specifier have no effect on whether a member of derived class may access to the members of its own direct base class. Access to the members of the base class is conrolled by the access specifer in the base class itself.
Both Pub_Deriv and Priv_Derv have access to the protected member prot_mem. Neither of them may access the private member Priv_mem.
The derivation access specifier is to control the access that users of the derived class - including other classed derived from the derived class - have to the members inherited from base.
Pub_Derv d1; // members inherited from Base remain the same access specifer
Priv_Derv d2; // members inherited from Base are private
d1.pub_mem(); // ok. pub_mem is public in the derived class
d2.pub_mem(); // error. pub_mem is private in the derived class
The derivation access specifier used by the derived class also control the access from classed that inherited from the derived class.
struct Drived_from_public : public Pub_Derv{
// ok. Base::prot_mem remain protected in Pub_Derv
int use_base(){ return prot_mem; }
}; struct Derived_from_private : public Priv_Derv{
// error. Base::prot_mem is private in Priv_Derv
int use_base() { return prot_mem; }
};
Had we defined another class, say, Prot_Derv, that use protected inheritance, the public members of base would be protected members in that class. Users of prot_Derv would have no access to Pub_mem, but members and friends of Prot_Derv have access to the inherited members.
Assumig D inherits from B.
User code may use the derived-to-base conversion only if D inherits publicly from B. User code may not use the conversion if D inherits from B using either protected or private.
An implementation member should be protected if it provides operation or data that a derived class will use in its own implementation. Otherwise, implementation member should be private.
friendship and inheritance
Just as friendship is not transitive, friendship is also not inherited.
Friends of the base type have no special access to the members of the derived class. Friends of the derived type also have no special access to the members of the base type.
class Base{
// remain other members as before
friend class pal;
}; class Pal{
public:
int f(Base b) { return b.prot_mem; } // ok
int f2(Sneaky s) { return s.j; } // error. Pal is not friend of Sneaky
int f3(Sneaky s) { return s.prot_mem; } // ok!!!
}
The fact that f3 is legal may be surprising, but it follows the notion that each class controls access to its own members. Pal is a friend of Base. So it also have access to the Base object that embeded in an object of type derived from Base.
Tony: when a friend of a base type access to a member through the derived class of the base type, need to consider 1)whether this member is inherited from the base, 2) if yes, the actual access level of the member in the base type.
When a class make another class a friend, it is only that class to which friendshp is granted. The base class class of, and the derived class from, the friend have no special access to the members of the befriending class.
class D2 : public Pal{
public:
// error. friendship is not inherited.
int mem(Base b) { return b.prot_mem; }
};
Exempting Individual Members
Sometimes we need to change the access level to a mambers that a class inherits. We can do so by providing a using declaration.
class Base{
public:
size_t size() const { return n; }
protected:
size_t n;
}; class Derived : private Base{
public:
using Base::size;
protected:
using Base::n;
};
Tony: private derivation do not support implicit derived-to-base conversion; then it also do not support polymorphism. So, privevation derivation is not a common use in OOP. The effective use of changing access level to members in C++ is similar to that in Java.
Class Scope under Inheritance
class Disc_quote: public Quote{
public:
pair<size_t, double> discount_policy const {
return {quantity, discount};
}
// other members as before
}; Bulk_quote bulk;
Bulk_quote * bulkP = &bulk; // static and dynamic type are the same
Quote * itemP = & bulk; // static andy dynamic type differ
bulkP->discount_policy(); // ok
itemP->discount_policy(); // error itemP has type Quote*
Even though bulk has the member named discount_policy, that members is not visible to through itemP. The type of itemP points to Quote, which means that the search for discount_policy start in class Quote.
Bulk_quote bulk;
cout << bulk->isbn();
The use of the isbn is resolved as follow:
Because we call isbn on an object of Bulk_quote, the research start in Bulk_quote. The name isbn is not found in that class.
Because Bulk_quote is derived from Disc_quote, the Disc_quote is searched next. The name isbn is not found.
Because Disc_quote is derived from Quote, The Quote is searched next. The name isbn is found in that class, the use of isbn is resolved to the isbn in Quote.
As usual, names defined in the inner scope(e.g. a derived class) hides the same names of outer scope(e.g. the base class).
We can use a hidden base-class memer by scope operator:
struct Derived : Base{
int get_base_mem() { return Base::mem; }
// ...
};
Aside from overriding inherited virtual function, a derived class should not reuse the names defined in its base class.
Functions defined in a derived class do not override members defined in its base class. If a memebers in a derived class has the same name as the base member, then the base member is hidden even if they have different parameter list
struct Base{
int memfcn();
}; struct Derived : Base{
int memfcn(int); // hides memfcn in the base
}; Base b;
Derived d;
b.memfcn();
d.memfcn();
d.memfcn(); // error: memfcn with no argument is hidden
d.Base::memfcn(); // ok
To resolve this call, look for name memfcn in Derived. The name is found, then compiler stop further search. The version of memfcn in Derived expected an int argument. This call provide no argument; it is in error.
class D1{
public:
int fcn(int);
}; class D2 : public D1{
public:
int fcn(int); // nonvirtual function hide D1::fcn(itn)
}; D2 d2Obj;
D1 *p1 = &d2Obj;
D2 *p2 = &d2Obj;
p1->fcn(); // statically bound, call D1::fcn(int)
p2->fcn(); // statically bound, call D2::fcn(int)
When we call an nonvirtual function, the version that is called depends only on the static type of the object. The dynamic type is ignored.
Override Overload Functions
If a derived class want to make ll overload functions of base available through its type, then it must override all of them or non of them.
Instead of Override every base class version that it inherits, a derived class can provide using declaration for the overload function. A using declaration only specifier a name. Thus, using declaration for a base members adds all instances of the overload function into the scope of the derived class.
Reference:
C++ Primer, Fifth Edition, chapter 15 Object-Oriented Programming
[C++] OOP - Access Control and Class Scope的更多相关文章
- Oracle Applications Multiple Organizations Access Control for Custom Code
档 ID 420787.1 White Paper Oracle Applications Multiple Organizations Access Control for Custom Code ...
- [认证授权] 6.Permission Based Access Control
在前面5篇博客中介绍了OAuth2和OIDC(OpenId Connect),其作用是授权和认证.那么当我们得到OAuth2的Access Token或者OIDC的Id Token之后,我们的资源服务 ...
- Role-based access control modeling and auditing system
A role-based access control (RBAC) modeling and auditing system is described that enables a user to ...
- Browser security standards via access control
A computing system is operable to contain a security module within an operating system. This securit ...
- A GUIDE TO UNDERSTANDINGDISCRETIONARY ACCESS CONTROL INTRUSTED SYSTEMS
1. INTRODUCTION The main goal of the National Computer Security Center is to encourage the widespr ...
- Enhancing network controls in mandatory access control computing environments
A Mandatory Access Control (MAC) aware firewall includes an extended rule set for MAC attributes, su ...
- Access control differentiation in trusted computer system
A trusted computer system that offers Linux® compatibility and supports contemporary hardware speeds ...
- Risk Adaptive Information Flow Based Access Control
Systems and methods are provided to manage risk associated with access to information within a given ...
- Extensible Access Control List Framework
Methods, systems, and products for governing access to objects on a filesystem. In one general embod ...
随机推荐
- Asset Catalogs
原文见这里. Asset Catalogs用于简化管理程序内用到的图片.每个asset catalog可以包含image set, App Icon, Launch Image和OS X Icon(如 ...
- Subclass UICollectionViewFlowLayout,自定义流布局
需求:为实现第一行显示一个,第二行以后显示两个 方案1:用系统自带的流布局,实现的效果是,若第二行只有一个,则系统默认会居中显示,不是左对齐(如下图),不符合项目要求. 方案2:自定义系统的UICol ...
- Java5~11新特性
Java5~11版本新特性 Java5 Java6 Java7 Java8 Java9 Java10 Java11 Java5 Java5开发代号为Tiger(老虎),于2004-09-30发行 特性 ...
- ORACLE GOLDEN GATE oracle同步数据至kafka
一.服务器信息 ip 软件版本 ogg版本 软件包 操作系统版本 OGG安装路径 10.1.50.52 源 oracle11.2.0.4 12.2.0.1.1 V100692-01.zip cen ...
- DBUtils 学习使用
DBUtils 学习使用 commons-dbutils简介 commons-dbutils是Apache组织提供的一个开源JDBC工具类库,它是对JDBC的简单封装,学习成本极低,并且使用dbuti ...
- ubuntu14.04安装qt-4.8.4
题记:因为工作中用到qt的qmake工具生成x项目的Makefile文件,因为原有工程用的是4.8.4版本的,因此在此基础之上安装此版本. 用安装包工具进行安装qt不能直接安装到4.8.4版本的,因此 ...
- echarts 多图任意布局案例
随着文档的更新,布局越来越个性化,完全可以替代整个元素界面,随意布局展示数据,下面发布一个小的文件 源码文件:https://files.cnblogs.com/files/mobeisanghai/ ...
- html5 video获取当前时间和视频总时间长度
html: <video id="video-active" class="video-active" width="640" hei ...
- 理解golang中的channel
channel是goroutine之间的通信机制.可以类比线程间的通信,线程间的通信有多种方式,比如线程上下文.共享内存.IPC通信.socket实现不同机器间的通信. channel用起来很简单,绑 ...
- HTTPS相关知识以及在golang中的应用
最近简单学习了HTTPS,并在golang中实践了一下,现在把学到的知识记录下来,方便以后查看,如果有幸能帮到有需要的人就更好了,如果有错误欢迎留言指出. 一些简单的概念,可以自行百度百科 HTTPS ...