【c++】访问控制

1. 类内的访问控制

在基类中，public和private具有普通的含义：用户（即基类的对象）可以访问public成员（包括函数、数据），而不能访问private成员。private只能被基类的成员和友员访问。（注:基类的对象无权访问private成员）
派生类对基类的public和private具有相同的含义：它可以访问public成员，不可以访问private成员。派生类对象亦如此。
为了使派生类（注：是类, 不是类对象）可以基类的成员，但禁止基类的对象访问，定义了protected控制。基类protected成员，派生类可以访问，但基类以及派生类的对象是不行的。

示例

#include <iostream>
#include <stdexcept>
#include <string>
#include <vector>
using namespace std;

class Item_base
{
    public:
        Item_base(const string &book = "", double sales_price = 0.0) : isbn(book), price(sales_price) {};
        virtual ~Item_base() {}
    private:
        string isbn;
    protected:
        double price;
};
class Bulk_item : public Item_base
{
    public:
        void print_hello() { cout << price << endl; }
};


int main()
{
    Bulk_item b;
    b.print_hello();
}

结果

2. 派生列表的访问控制

派生类中由两部分构成：基类的一部分+自身定义的一部分。派生类列表中访问控制，将影响基类的部分在派生类中的访问级别：

如果为公有继承：派生类中的基类成员保持自己的访问级别：public还是public, private还是private，protected还是protected
如果为私有继承：派生类中基类的所有成员将全部为private成员
如果为受保护继承：派生类中基类的public、protected成员变为protected成员，private还是private

总之：派生类可以进一步限制，但是不可以放松对所有继承成员的访问

注意：私有继承类成员中仍可以访问基类的public, private成员，只是基类的部分在派生类中的性质变为：private。

例证1

#include <iostream>
#include <string>
using namespace std;

class base
{
    public:
        base(int p1=1, int p2=2, int p3=3) : pub(p1), pri(p2), pro(p3) {}
        int pub;
    private:
        int pri;
    protected:
        int pro;
};

class derived_private : protected base
{
    public:
        void print_pri() 
        { 
            cout << "pub:" << pub << endl;
            cout << "pro:" << pro << endl;
        }
};

int main()
{
    base b;
    derived_private d;
    d.print_pri();
}

结果1

例证2

#include <iostream>
#include <string>
using namespace std;

class base
{
    public:
        base(int p1=1, int p2=2, int p3=3) : pub(p1), pri(p2), pro(p3) {}
        int pub;
    private:
        int pri;
    protected:
        int pro;
};

class derived_private : private base
{
    public:
        void print_pri() 
        { 
            cout << "pub:" << pub << endl;
            cout << "pro:" << pro << endl;
        }
};

int main()
{
    base b;
    derived_private d;
    cout << d.pub << endl;
    cout << d.pri << endl;
    cout << d.pro << endl;
}

结果2