C ++友元的浅析（一）

一、友元函数定义：友元函数是指某些虽然不是类成员却能够访问类的所有成员的函数。。类授予它的友元特别的访问权。通常同一个开发者会出于技术和非技术的原因，控制类的友元和成员函数（否则当你想更新你的类时，还要征得其它部分的拥有者的同意）；类具有封装和信息隐藏的特性。只有类的成员函数才能访问类的私有成员，程序中的其他函数是无法访问私有成员的。非成员函数可以访问类中的公有成员，但是如果将数据成员都定义为公有的，这又破坏了隐藏的特性。另外，应该看到在某些情况下，特别是在对某些成员函数多次调用时，由于参数传递，类型检查和安全性检查等都需要时间开销，而影响程序的运行效率。

二、友元函数案例

1.全局友元函数

    如果这个函数不是定义在class中，并且它可以用来操作其他class的私有属性，称之为全局友元函数。案例如下：

#include <iostream>

using namespace std;

class A{
private:
    int a;
public:
    //申明友元函数
    friend void show(A &a);
    A(){
        cout << "类A被构造" << endl;
        a = 20;
    }
    ~A(){
        cout << "类A被析构" << endl;
    }
};

//全局友元函数
void show(A &a){
    //访问classA的私有成员
    cout << "a="<<a.a <<endl;
}

class B{
private:
    int b;
public:
    B(){
        A a;
        show(a);
        cout << "类B的构造" << endl;
        b = 12;
    }
    ~B(){
        cout << "类B被析构" << endl;
    }
};

int main(){
    B b;
    return 0;
}

上述案例中 void show(A &a)  为全局友元函数，他可以访问class A 的私有成员a,可以这样理解，函数void show(...)是class A的朋友，故它可以访问classA的资源。定义友元函数很简单，只需要在class A中申明show函数，并在申明前添加frien关键字

2.友元类

友元除了前面讲过的函数以外，友元还可以是类，即一个类可以作另一个类的友元。当一个类作为另一个类的友元时，这就意味着这个类的所有成员函数都是另一个类的友元函数。案例如下：

#include <iostream>

using namespace std;

class A{
private:
    int a;
public:
    friend class B;
    A(){
        cout << "类A被构造" << endl;
        a = 20;
    }
    ~A(){
        cout << "类A被析构" << endl;
    }
};



class B{
private:
    int b;
public:
    B(){
        A a;
        show(a);
        cout << "类B的构造" << endl;
        b = 12;
    }
    ~B(){
        cout << "类B被析构" << endl;
    }
    //友元类函数
    void show(A &a){
        //访问classA的私有成员
        cout << "a="<<a.a <<endl;
    }
};

int main(){
    B b;
    return 0;
}

在class 中定义了friend class B;即class B 为classA的友元类，classB 中的所有成员函数都是classA的友元函数，它们可以访问classA 中的私有成员.注意这时，友元是单向的，这时class A 中的函数不能访问class B中的内容。

3.互为友元类

   如何实现classA与B互为友元，即A可以访问B的私有，B也可以访问A的私有呢？案例如下：

#include <iostream>

using namespace std;
//必须提前声明class B不然编译会报错
class B;
class A{
private:
    int a;
public:
    friend class B;

    A(){
        cout << "类A被构造" << endl;
        a = 20;
    }
    ~A(){
        cout << "类A被析构" << endl;
    }
    void show(B & b);
};

class B{
private:
    int b;
public:
    friend class A;
    B(){
        cout << "类B的构造" << endl;
        b = 12;
    }
    ~B(){
        cout << "类B被析构" << endl;
    }
    void show(A &a){
        cout << "a="<<a.a ;
        cout << " b=" <<b<<endl;
    }
};
//函数不能放在class A 中，不然会编译报错
void A::show(B &b){
    cout << "a="<<a ;
    cout << " b="<<b.b<< endl;
}

int main(){
    A a;
    B b;
    a.show(b);
    b.show(a);

    return 0;
}

运行结果：

类A被构造
类B的构造
a=20 b=12
a=20 b=12
类B被析构
类A被析构

互为友元类的做法就是，在classA中声明 friend class B ;在classB 中声明friend class A;
注意：类A中使用到了类B的地方必须在类B的声明后定义，在类A中只能声明。例如左边类A中的show函数，不能在类A中直接定义，只能放在类B的声明之后定义。

文章出处：http://www.th7.cn/Program/cp/201411/320603.shtml