In the previous lessons on inheritance, we’ve been making all of our data members public in order to simplify the examples. In this section, we’ll talk about the role of access specifiers in the inheritance process, as well as cover the different types of
inheritance possible in C++.

To this point, you’ve seen the private and public access specifiers, which determine who can access the members of a class. As a quick refresher, public members can be accessed by anybody. Private members can only be accessed by member functions of the same
class. Note that this means derived classes can not access private members!

1
2
3
4
5
6
7
class
Base
{
private:
    int
m_nPrivate; // can only be accessed by Base member functions (not derived classes)
public:
    int
m_nPublic; // can be accessed by anybody
};

When dealing with inherited classes, things get a bit more complex.

First, there is a third access specifier that we have yet to talk about because it’s only useful in an inheritance context. The
protected access specifier restricts access to member functions of the same class, or those of derived classes.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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
}

Second, when a derived class inherits from a base class, the access specifiers may change depending on the method of inheritance. There are three different ways for classes to inherit from other classes: public, private, and protected.

To do so, simply specify which type of access you want when choosing the class to inherit from:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 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
{
};

If you do not choose an inheritance type, C++ defaults to private inheritance (just like members default to private access if you do not specify otherwise).

That gives us 9 combinations: 3 member access specifiers (public, private, and protected), and 3 inheritance types (public, private, and protected).

The rest of this section will be devoted to explaining the difference between these.

Before we get started, the following should be kept in mind as we step through the examples. There are three ways that members can be accessed:

  • A class can always access it’s own members regardless of access specifier.
  • The public accesses the members of a class based on the access specifiers of that class.
  • A derived class accesses inherited members based on the access specifiers of its immediate parent. A derived class can always access it’s own members regardless of access specifier.

This may be a little confusing at first, but hopefully will become clearer as we step through the examples.

Public inheritance

Public inheritance is by far the most commonly used type of inheritance. In fact, very rarely will you use the other types of inheritance, so your primary focus should be on understanding this section. Fortunately, public inheritance is also the easiest
to understand. When you inherit a base class publicly, all members keep their original access specifications. Private members stay private, protected members stay protected, and public members stay public.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
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
}

This is fairly straightforward. The things worth noting are:

  1. Derived classes can not directly access private members of the base class.
  2. The protected access specifier allows derived classes to directly access members of the base class while not exposing those members to the public.
  3. The derived class uses access specifiers from the base class.
  4. The outside uses access specifiers from the derived class.

To summarize in table form:

Public inheritance
Base access specifier Derived access specifier Derived class access? Public access?

Public Public Yes Yes
Private Private No No
Protected Protected Yes No

Private inheritance

With private inheritance, all members from the base class are inherited as private. This means private members stay private, and protected and public members become private.

Note that this does not affect that way that the derived class accesses members inherited from its parent! It only affects the code trying to access those members through the derived class.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
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
}

To summarize in table form:

Private inheritance
Base access specifier Derived access specifier Derived class access? Public access?
Public Private Yes No
Private Private No No
Protected Private Yes No

Protected inheritance

Protected inheritance is the last method of inheritance. It is almost never used, except in very particular cases. With protected inheritance, the public and protected members become protected, and private members stay private.

To summarize in table form:

Protected inheritance
Base access specifier Derived access specifier Derived class access?

Public access?
Public Protected Yes No
Private Private No No
Protected Protected Yes No

Protected inheritance is similar to private inheritance. However, classes derived from the derived class still have access to the public and protected members directly. The public (stuff outside the class) does not.

Summary

The way that the access specifiers, inheritance types, and derived classes interact causes a lot of confusion. To try and clarify things as much as possible:

First, the base class sets it’s access specifiers. The base class can always access it’s own members. The access specifiers only affect whether outsiders and derived classes can access those members.

Second, derived classes have access to base class members based on the access specifiers of the immediate parent. The way a derived class accesses inherited members is not affected by the inheritance method used!

Finally, derived classes can change the access type of inherited members based on the inheritance method used. This does not affect the derived classes own members, which have their own access specifiers. It only affects whether outsiders and classes derived
from the derived class can access those inherited members.

A final example:

1
2
3
4
5
6
7
8
9
class
Base
{
public:
    int
m_nPublic;
private:
    int
m_nPrivate;
protected:
    int
m_nProtected;
};

Base can access it’s own members without restriction. The public can only access m_nPublic. Derived classes can access m_nPublic and m_nProtected.

1
2
3
4
5
6
7
8
9
class
D2: private
Base
{
public:
    int
m_nPublic2;
private:
    int
m_nPrivate2;
protected:
    int
m_nProtected2;
}

D2 can access it’s own members without restriction. D2 can access Base’s members based on Base’s access specifiers. Thus, it can access m_nPublic and m_nProtected, but not m_nPrivate. Because D2 inherited Base privately, m_nPublic, m_nPrivate, and m_nProtected
are now private when accessed through D2. This means the public can not access any of these variables when using a D2 object, nor can any classes derived from D2.

1
2
3
4
5
6
7
8
9
class
D3: public
D2
{
public:
    int
m_nPublic3;
private:
    int
m_nPrivate3;
protected:
    int
m_nProtected3;
};

D3 can access it’s own members without restriction. D3 can access D2′s members based on D2′s access specifiers. Thus, D3 has access to m_nPublic2 and m_nProtected2, but not m_nPrivate2. D3 access to Base members is controlled by the access specifier of it’s
immediate parent. This means D3 does not have access to any of Base’s members because they all became private when D2 inherited them.

http://www.learncpp.com/cpp-tutorial/115-inheritance-and-access-specifiers/

Public Private Protect Inheritance and access specifiers的更多相关文章

  1. public private protect

    public 公有  使用public意味着声明public之后的成员对每个人都是可用的 private 私有  除非必须公开底层实现细目,否则就应该将所有的域指定为private protect 继 ...

  2. public private, protect. 以及继承。 草稿。

    #include <iostream>#include <thread>#include <memory> // | 父类的public成员 | 父类的protec ...

  3. C++ public private protect 继承关系(链接)

    基础链接 总结:  public继承基类成员访问权限没有变化; protected继承基类public和protected权限变为protected,基类private不变. private继承基类p ...

  4. public、protect、private在父类子类中使用

    先贴出一张,直观的.估计大家都见过的关于public.protect.private的范围图 作用域 当前类 同一package 子孙类 其他package public     T         ...

  5. c/c++再学习:C++中public、protect、private的访问权限控制

    C++中public.protect.private的访问权限控制 访问权限 一个类的public成员变量.成员函数,可以通过类的成员函数.类的实例变量进行访问 一个类的protected成员变量.成 ...

  6. c++三种继承方式public,protect,private

    C++中的三种继承public,protected,private 三种访问权限 public:可以被任意实体访问 protected:只允许子类及本类的成员函数访问 private:只允许本类的成员 ...

  7. c++ 之private /protect/ public

    C++中public.protect.private的访问权限控制 访问权限 一个类的public成员变量.成员函数,可以通过类的成员函数.类的实例变量进行访问 一个类的protected成员变量.成 ...

  8. 深入浅出OOP(五): C#访问修饰符(Public/Private/Protected/Internal/Sealed/Constants)

    访问修饰符(或者叫访问控制符)是面向对象语言的特性之一,用于对类.类成员函数.类成员变量进行访问控制.同时,访问控制符也是语法保留关键字,用于封装组件. Public, Private, Protec ...

  9. public private protected和默认的区别(转自百度)

    public private protected和默认的区别 Java中对类以及类中的成员变量和成员方法通过访问控制符(access specifier)进行区分控制.刚学Java语言的同学可能对pu ...

随机推荐

  1. curator管理es索引

    安装curator------------------rpm --import https://packages.elastic.co/GPG-KEY-elasticsearch vi /etc/yu ...

  2. Xamarin开发安装Visual Studio 2015 update2报错的解决办法

    Xamarin开发安装Visual Studio 2015 update2报错的解决办法错误信息:update 2 requires a member of the visual studio 201 ...

  3. POJ2234 Matches Game 尼姆博弈 博弈论

    http://poj.org/problem?id=2234 尼姆博弈(Nimm's Game) 指的是这样一个博弈游戏:有任意堆物品,每堆物品的个数是任意的,双方轮流从中取物品,每一次只能从一堆物品 ...

  4. 138.括号序列(区间型DP)

    3657 括号序列  时间限制: 1 s  空间限制: 256000 KB  题目等级 : 黄金 Gold 题解 查看运行结果 题目描述 Description 我们用以下规则定义一个合法的括号序列: ...

  5. [转]jquery后代和子元素的区别

    这是<锋利的jquery>书里的内容 <div>     <p>         <span></span>         <a&g ...

  6. Educational Codeforces Round 9 C. The Smallest String Concatenation 排序

    C. The Smallest String Concatenation 题目连接: http://www.codeforces.com/contest/632/problem/C Descripti ...

  7. PHP 5.3.13 memcache win 64 配置和安装

    --环境: windows 2008 R2 64位 wampserver2.2e-php5.3.13-httpd2.2.22-mysql5.5.24-x64 --目标: 实现 php 用memcach ...

  8. OpenVPN记住账号密码自动连接

    说明:在增加了证书+账号密码之后,安全性确实提高了,但是面临的问题也有,每次重启时必须输入账号密码才能连接,这也造成了无人值守的问题. 解决: 1.在Client的client.ovpn末尾添加一行a ...

  9. __FILE__,__LINE__,FUNCTION__实现代码跟踪调试

    转:http://www.cnitblog.com/zouzheng/archive/2007/08/31/32691.aspx 先看下简单的初始代码:注意其编译运行后的结果. root@xuanfe ...

  10. Index column size too large. The maximum column size is 767 bytes.

    mysql建表时报Index column size too large. The maximum column size is 767 bytes.解决办法:在建表语句的后面加入:ENGINE=In ...