《c++ prime》读书笔记－－继承和访问控制

基本规则  

  在基类中，public和private标号具有普通意义：用户代码可以访问类的public成员而不能访问private成员，private成员只能 由基类的成员和友元访问。派生类对基类的public和private成员的访问权限与程序中任意其他部分一样：它可以访问pubic成员而不能访问 private成员。

  有时作为基类的类具有一些成员，他希望允许派生类访问但继续禁止其他用户访问这些成员，对于这样的成员应该使用受保护的访问标号（protected），protected成员可以被派生类对象访问但不能被该类型的普通用户访问。

  下面是代码演示

#include <iostream>
using namespace std;

class Base
{
private:
    int pri;
protected:
    int pro;
public:
    Base(int i, int j):pri(i),pro(j){}
    int get_pri(){ return pri; }
    int get_pro(){ return pro; }
};
class Derived : public Base
{
private:
    int d_pri;
protected:
    int d_pro;
public:
    Derived(int i, int j):Base(0,0), d_pri(i), d_pro(j){}
    //int dget_pri(){ return pri; }    //error
    int dget_pro(){ return pro; }
    int get_d_pri(){ return d_pri; }
    int get_d_pro(){ return d_pro; }
};

int main()
{
    Base b(1, 2);
    Derived d(3,4);

    //cout << b.pri << endl;    //error
    //cout << b_pro << endl;    //error
    cout << b.get_pri() << endl;    //ok

    //cout << d.d_pri << endl;    //error
    //cout << d.d_pro << endl;    //error
    //cout << d.pri << endl;    //error
    //cout << d.pro << endl;    //error
    cout << d.dget_pro() << endl;    //ok
    cout << d.get_d_pro() << endl;    //ok
}

protected成员

  可以认为protected访问标号是private和public的混合：

    1. 像private成员一样,protected成员不能被类的用户访问

    2. 像public成员一样,protected成员可被该类的派生类访问

  此外,protected还有另一个重要的性质:

    1. 派生类只能通过派生类对象访问其基类的protected成员,派生类对其基类类型对象的protected成员没有特殊访问权限

  通过下面的例子具体说明

#include <iostream>
using namespace std;

class Base
{
private:
    int pri;
protected:
    int pro;
public:
    Base(int i, int j):pri(i), pro(j){}
};

class Derived : public Base
{
private:
    int d_pri;
protected:
    int d_pro;
public:
    Derived(int i, int j):Base(0,0), d_pri(i), d_pro(j){}
    int sum(const Derived &d, const Base &b)
    {
        int ret;
        //ret = d.d_pri + b.pro;    //error
        ret = d.d_pri + Base::pro;    //ok
        return ret;
    }
};

int main()
{
    Base b(1, 2);
    Derived d(3, 4);
    Derived d2(5, 6);

    cout << d.sum(d2, b) << endl;
}

公有,私有和受保护的继承

  基类本身指定对自身成员的最小访问控制.如果成员在基类中为private,则只有基类和基类的友元可以访问该成员.派生类不能访问基类的private 成员,也不能使自己的用户能够访问那些成员.如果基类成员为public或者protected,则派生列表中使用的访问标号决定该成员在派生类中的访问 级别:

    1. 如果是公用继承,基类成员保持自己的访问级别:基类的public成员为派生类的public成员,基类的protected成员为派生类的protected成员.

    2. 如果是受保护的继承,基类的public和protected成员在派生类中为protected成员

    3. 如果是私有继承,基类的所有成员在派生类中为private成员.

#include <iostream>
using namespace std;

//
//base class
//
class Base
{
private:
    int b_pri;
protected:
    int b_pro;
public:
    Base(int i, int j):b_pri(i), b_pro(j){}
    int get_pri(){ return b_pri; }
};
//
//inherit by Base with the access lable :public
//
class public_D : public Base
{
private:
    int pd_pri;
protected:
    int pd_pro;
public:
    public_D(int i, int j):Base(0, 0), pd_pri(i), pd_pro(j){}
    int get_b_pro(){ return b_pro; }
};
//
//inherit by Base withe the access lable :private
//
class private_D : private Base
{
private:
    int pri_pri;
protected:
    int pri_pro;
public:
    private_D(int i, int j):Base(0, 0), pri_pri(i), pri_pro(j){}
    int get_b_pro(){ return b_pro; }
    //int get_b_pri(){ return b_pri; }    //can't get access to b_pri in Base class
};
//
//inherit by Base withe the access lable :protected
//
class protected_D : protected Base
{
private:
    int pro_pri;
protected:
    int pro_pro;
public:
    protected_D(int i, int j):Base(0, 0), pro_pri(i), pro_pro(j){}
    int get_b_pro(){ return b_pro; }
};

int main()
{
    Base b(1, 2);
    public_D pub_d(3, 4);
    private_D pri_d(5, 6);
    protected_D pro_d(7, 8);
    //
    //print the datas to see whether the rules is true
    //
    cout << "b.get_pri() = " << b.get_pri() << endl;
    cout << "pub_d.get_b_pro() = " << pub_d.get_b_pro() << endl;
    cout << "pri_d.get_b_pro() = " << pri_d.get_b_pro() << endl;
    cout << "pri_d.get_b_pri() = " << pri_d.get_b_pro() << endl;
    cout << "pro_d.get_b_pro() = " << pro_d.get_b_pro() << endl;     
}

完毕