乐趣区

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

jiezi
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;
}

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

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

退出移动版