关于c++:c类访问权限及友元

1.类的拜访权限

class是c++的类申明关键字，它的成员类型有三种，是应用三个关键字来申明的，别离是public、private、protected，public申明的叫做私有成员，private申明的是公有成员，protected申明的则是爱护成员。

1)public-私有成员

首先看一下public申明的私有成员：

class A{public:    int a;    int b;public:    int add();private:    int sub();protected:    int mul();};int A::add(){    return a+b;}int A::sub(){    return a-b;}int A::mul(){    return a*b;}int main(){    A a;    a.a = 2;    a.b = 3;    return 0;}

对于以上代码，编译通过，阐明对于私有成员a和b，私有成员函数、公有成员函数、爱护成员函数以及类对象都是能够间接进行拜访的。

2)private-公有成员

接下来将成员变量a申明为公有，如下：

class A{private:    int a;public:    int b;public:    int add();private:    int sub();protected:    int mul();};int A::add(){    return a+b;}int A::sub(){    return a-b;}int A::mul(){    return a*b;}int main(){    A a;    a.a = 2;    a.b = 3;    return 0;}

编译时报错如下：

test.cpp: In function ‘int main()’:test.cpp:33:4: error: ‘int A::a’ is private within this context

编译报错的意思是第33行，a是一个公有成员，不能间接拜访，那么将33行正文掉，而后再编译，能够通过。
综上，阐明对于公有成员a，私有成员函数、公有成员函数、爱护成员函数都能够间接进行拜访，但类对象不能间接拜访。

3)protected-爱护成员

同上，将a申明为protected类型，后果与申明为private是统一的，阐明至多在这个类自身以及它的对象而言，private和protected作用是统一的。

接下来申明一个类B，私有继承类A，看一下后果怎么样：

class A{protected:    int a;private:    int b;public:    int add();private:    int sub();protected:    int mul();};int A::add(){    return a+b;}int A::sub(){    return a-b;}int A::mul(){    return a*b;}class B : public A{    B()    {        a = 2;    }};int main(){    A a;    //a.a = 2;    //a.b = 3;    return 0;}

a为爱护成员，b为公有成员，子类B间接拜访a，编译通过。
而后将a改为b，编译报错如下：

test.cpp: In constructor ‘B::B()’:test.cpp:34:3: error: ‘int A::b’ is private within this context

从这里看，对于子类而言，公有成员和爱护成员的拜访权限是不同的。

综上所述，public阐明在它前面申明的所有成员对类的所有成员以及所有类对象都是能够存取的，private阐明只有类的外部成员函数能够存取，类对象以及指针都是不容许间接拜访的，protected与private根本类似，惟一的一点不同是父类定义的private成员，子类不能够拜访，然而父类定义的protected成员，子类是能够拜访的。

另外在struct中，也是能够应用这三个关键字的，用法与class基本一致，不同之处是，如果struct某个成员没有指明类型，那么默认是public的，而class默认是private的。

2.友元

如果想容许不属于以后类的一个函数存取以后类中的成员，那么要怎么能力做到呢，答案是友元。所谓友元，顾名思义是咱们成为敌人了，关系曾经比拟亲热了，能够适当的参加对方的生存了。友元关键字是friend，咱们能够在一个类的外部申明一个友元函数、友元类，或者A类的成员函数也能够被申明为B类的友元。

首先申明一个友元函数，如下：

class A{protected:    int a;private:    int b;protected:    int c;public:    //友元函数不属于类的成员，所以它不受其所在类的申明区域public,private,protected的影响    friend void g(A* a, int x);};void g(A* a, int x){    a->a = x;    a->b = x;    a->c = x;}int main(){    return 0;}

编译通过，那么阐明一个友元函数拜访类的私有、公有以及爱护成员都是不受限制的。

上面申明友元类，如下：

class A{protected:    int a;private:    int b;protected:    int c;public:    //友元函数不属于类的成员，所以它不受其所在类的申明区域public,private,protected的影响    friend void g(A* a, int x);    friend class B;};void g(A* a, int x){    a->a = x;    a->b = x;    a->c = x;}class B{public:    B(A *a, int x)    {        a->a = x;        a->b = x;        a->c = x;    }};int main(){    A *a = new A();    B b(a, 2);    return 0;}

编译也能够通过，那么阐明对于友元类而言，类的公有成员和爱护成员都是能够间接被拜访的。

对于在类中被申明为友元的对象而言，不论是类的私有、公有还是爱护成员，都是能够间接拜访的。