OOP-访问限制

• public

公用的,任何人都可以访问

• private

私有的,类的成员函数可以访问,同一个类的对象可以互相访问private

#include <iostream>
using namespace std;
class A
{
private:
    int i;
    int *p;

public:
    A()
    {
        p = 0;
        cout << "A::A()" << endl;
    }
    ~A()
    {
        if (p)
        {
            delete p;
            cout << "A::~A()" << endl;
        }
    }
    void set(int ii)
    {
        i = ii;
    }
    void f()
    {
        p = new int;
    }
    void g(A *q)
    {
        cout << "A::g(),q->i=" << q->i << endl;
    }
};
int main()
{
    A *p = new A[3];
    for (int i = 0; i < 3; i++)
    {
        p[i].set(i);
    }
    A b;
    b.set(100);
    p[0].g(&b); //友元访问
    delete[] p;
    return 0;
}

• protected

类的子子孙孙可以访问，但是不能访问private

• c++的Friends

友元函数是可以直接访问类的私有成员的非成员函数。它是定义在类外的普通函数，它不属于任何类，但需要在类的定义中加以声明，声明时只需在友元的名称前加上关键字friend，其格式如下：
friend 类型 函数名(形式参数);

可以自由访问其private

一个例子

#include <iostream>
using namespace std;
class Point //声明
{
public:
    Point(double xx, double yy)
    {
        x = xx;
        y = yy;
    } //默认构造函数
    friend double Distance(Point &a, Point &b); //友元函数
private:
    double x, y;
};
double Distance(Point &a, Point &b) //注意函数名前未加类声明符
{
    double dx = a.x - b.x;
    double dy = a.y - b.y;
    return dx * dx + dy * dy;
}
int main()
{
    Point p1(3.0, 4.0), p2(6.0, 8.0);
    double d = Distance(p1, p2);
    cout << "Distance is " << d << endl;
}

class vs struct
class默认private sturct默认public 继承的几种方式上述第一层访问控制符（即派生列表中）影响的是派生类中基类部分成员（函数或变量）的访问控制权限（也仅仅只有这一点影响），具体的影响为：
（1）public继承（保持不变）：派生类中基类部分的成员（函数或变量）的访问控制权限和其在基类中声明的权限一样；
（2）protected继承（各自降低一个权限）：基类中public成员在派生类中变成protected权限，其他成员都变为private权限；
（3）private继承（全部私有化）：派生类中基类部分的成员（函数或变量）的访问控制权限全部变为private成员。一个关于访问限制的例子

一个关于访问限制的例子

class Base
{
public:
    int pub_mem;

protected:
    int pro_mem;

private:
    int pri_mem;

    //对类自身来说，其成员函数，无论何种权限说明，都可以访问类中的任何权限的成员变量
public:
    int base_fun_pub() {}

protected:
    int base_fun_pro() {}

private:
    int base_fun_pri() {}
};

class Drived : public Base
{
    //pub、pro、pri成员函数都能访问其基类部分的public、protected成员变量，但都不能访问private成员
public:
    int drived_fun_pub()
    {
        pub_mem = 0; //情况（1）
        pro_mem = 0; //情况（2）
        pri_mem = 0; //情况（3）（错误，不能访问）
    }

protected:
    int drived_fun_pro()
    {
        pub_mem = 0; //情况（1）
        pro_mem = 0; //情况（2）
        pri_mem = 0; //情况（3）（错误，不能访问）
    }

private:
    int drived_fun_pri()
    {
        pub_mem = 0; //情况（1）
        pro_mem = 0; //情况（2）
        pri_mem = 0; //情况（3）（错误，不能访问）
    }

private:
    int j;
};

void main()
{
    /******************单层public继承为例**********************/
    Drived drivedobj;
    drivedobj.pub_mem; //情况（1）
    drivedobj.pro_mem; //情况（2）（错误，不能访问）
    drivedobj.pri_mem; //情况（3）（错误，不能访问）
}