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.
classBase{ protected: intprot_item; }; class Sneaky : publicBase{ friend void clobber(Sneeky &); friend void clobber(Base &); intj; }; void clobber(Sneaky & s) { s.prote_item =0;} //ok //error: clobber cannot access the protect member in Base; void clobber(Base & b) { b.prot_item = 0;}
public, private and protect inheritance
classBase{ public: voidpub_mem(); protected: intprot_mem; private: charpriv_mem; } struct Pub_Derv : publicBase{ //ok. derived class can access protected members int f() { returnprot_mem; } //error. private members are inaccessible to derived class char g() { returnpriv_mem; } } struct Priv_Derv : privateBase{ //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 : publicPub_Derv{ //ok. Base::prot_mem remain protected in Pub_Derv int use_base(){ returnprot_mem; } }; struct Derived_from_private : publicPriv_Derv{ //error. Base::prot_mem is private in Priv_Derv int use_base() { returnprot_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.
classBase{ //remain other members as before friend classpal; }; classPal{ 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 : publicPal{ public: //error. friendship is not inherited. int mem(Base b) { returnb.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.
classBase{ public: size_t size() const { returnn; } protected: size_t n; }; class Derived : privateBase{ public: usingBase::size; protected: usingBase::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: publicQuote{ 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:
structDerived : Base{ int get_base_mem() { returnBase::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
structBase{ intmemfcn(); }; structDerived : Base{ int memfcn(int); //hides memfcn in the base }; Base b; Derived d; b.memfcn(); d.memfcn(31); 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.
classD1{ public: int fcn(int); }; class D2 : publicD1{ public: int fcn(int); //nonvirtual function hide D1::fcn(itn) }; D2 d2Obj; D1 *p1 = &d2Obj; D2 *p2 = &d2Obj; p1->fcn(41); //statically bound, call D1::fcn(int) p2->fcn(41); //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