1. Protected access specifier限定类成员只能被同一个class或derived class的成员函数访问
class Base
{
public:
int m_nPublic; // can be accessed by anybody
private:
int m_nPrivate; // can only be accessed by Base member functions (but not derived classes)
protected:
int m_nProtected; // can be accessed by Base member functions, or derived classes.
};
class Derived: public Base
{
public:
Derived()
{
// Derived's access to Base members is not influenced by the type of inheritance used,
// so the following is always true:
m_nPublic = 1; // allowed: can access public base members from derived class
m_nPrivate = 2; // not allowed: can not access private base members from derived class
m_nProtected = 3; // allowed: can access protected base members from derived class
}
};
int main()
{
Base cBase;
cBase.m_nPublic = 1; // allowed: can access public members from outside class
cBase.m_nPrivate = 2; // not allowed: can not access private members from outside class
cBase.m_nProtected = 3; // not allowed: can not access protected members from outside class
}
2. 类的继承有3种不同的方式: public, private, 和 protected
// Inherit from Base publicly
class Pub: public Base
{
};
// Inherit from Base privately
class Pri: private Base
{
};
// Inherit from Base protectedly
class Pro: protected Base
{
};
class Def: Base // Defaults to private inheritance
{
};
如最后一个所示,如果没有指定继承的类型,默认为private继承。
由以上两点,我们得到9种不同的组合:3 member access specifiers (public, private, and protected), and 3 inheritance types (public, private, and protected).
Public inheritance
这是最常见的一种继承类型,实际上其他几种则非常少见。当你以public的方式继承基时,所有的成员保持原有的访问限制,private成员仍是private,protected成员仍是protected,public成员仍是public。
class Base
{
public:
int m_nPublic;
private:
int m_nPrivate;
protected:
int m_nProtected;
};
class Pub: public Base
{
// Public inheritance means:
// m_nPublic stays public
// m_nPrivate stays private
// m_nProtected stays protected
Pub()
{
// The derived class always uses the immediate parent's class access specifications
// Thus, Pub uses Base's access specifiers
m_nPublic = 1; // okay: anybody can access public members
m_nPrivate = 2; // not okay: derived classes can't access private members in the base class!
m_nProtected = 3; // okay: derived classes can access protected members
}
};
int main()
{
// Outside access uses the access specifiers of the class being accessed.
// In this case, the access specifiers of cPub. Because Pub has inherited publicly from Base,
// no access specifiers have been changed.
Pub cPub;
cPub.m_nPublic = 1; // okay: anybody can access public members
cPub.m_nPrivate = 2; // not okay: can not access private members from outside class
cPub.m_nProtected = 3; // not okay: can not access protected members from outside class
}
值得注意的是
1) Derived class不能直接访问基类的private成员
2) Derived class可以直接访问基类的protected成员,前提是不会把这些成员暴露给public
3) Derived class uses access specifiers from the base class
4) Outside uses access specifiers from the derived class
Private inheritance
Private inheritance方式下,基类的所有成员都被归为private。
应该注意的是这种继承方式不影响派生类对所继承成员的访问,只影响试图通过派生类来访问继承成员的代码
class Base
{
public:
int m_nPublic;
private:
int m_nPrivate;
protected:
int m_nProtected;
};
class Pri: private Base
{
// Private inheritance means:
// m_nPublic becomes private
// m_nPrivate stays private
// m_nProtected becomes private
Pri()
{
// The derived class always uses the immediate parent's class access specifications
// Thus, Pub uses Base's access specifiers
m_nPublic = 1; // okay: anybody can access public members
m_nPrivate = 2; // not okay: derived classes can't access private members in the base class!
m_nProtected = 3; // okay: derived classes can access protected members
}
};
int main()
{
// Outside access uses the access specifiers of the class being accessed.
// Note that because Pri has inherited privately from Base,
// all members of Base have become private when access through Pri.
Pri cPri;
cPri.m_nPublic = 1; // not okay: m_nPublic is now a private member when accessed through Pri
cPri.m_nPrivate = 2; // not okay: can not access private members from outside class
cPri.m_nProtected = 3; // not okay: m_nProtected is now a private member when accessed through Pri
// However, we can still access Base members as normal through Base:
Base cBase;
cBase.m_nPublic = 1; // okay, m_nPublic is public
cBase.m_nPrivate = 2; // not okay, m_nPrivate is private
cBase.m_nProtected = 3; // not okay, m_nProtected is protected
}
Protected inheritance
这种继承方式非常罕见。在这种继承方式下,public和protected成员变成protected,private成员仍是private
Base access specifier | Derived access specifier | Derived class access | Public access |
---|---|---|---|
Public | Public | Yes | Yes |
Private | Private | No | No |
Protected | Protected | Yes | No |
Base access specifier | Derived access specifier | Derived class access | Public access |
---|---|---|---|
Public | Private | Yes | No |
Private | Private | No | No |
Protected | Private | Yes | No |
Base access specifier | Derived access specifier | Derived class access | Public access |
---|---|---|---|
Public | Protected | Yes | No |
Private | Private | No | No |
Protected | Protected | Yes | No |
总结
1) 基类总是可以访问自己的成员,access specifiers仅仅影响派生类和其他函数的访问权限
2) 派生类根据immediate parent的access specifier来访问继承的成员,派生类型不影响派生类的访问
3)