《C++语言教程》14章 友元函数(friend)

---

类的外部，也就是通过实例来访问私有(private)或保护(protected)成员，这是被禁止的。但从实用性来说，的确有时很需要在外部访问，C++增加了一种称之为“友元(friend)”函数的申明，将“特权”赋给一些函数(可以是全局函数，也可以是其它类的成员函数)，使之能够访问该类的私有和保护成员。

友元函数必须在类里面申明，而且友元函数一定不是该类的成员函数。因此，这样的“特权”实际上已经不是完全的面向对象设计了，当然，我们也可以不用它。另外，友元函数的申明在派生类无效，除非派生类中再申明一次，当然类型转换为基类时，使用没有任何问题。

要使用全局函数作友元函数，也就是说全局函数中要使用当前这个类的实例，因此，全局函数的定义必须放在这个类的后面，否则，编译时这个类的实例就成了未定义的数据类型了。

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

class ca {
    string id;
    void setId(string s) {
        id = s;
    }
protected:
    string name;
    void setName(string s) {
        name = s;
    }
public:
    void print() {
        cout << id << "  " << name << "  " << endl;
    }
    friend void fun(ca& a);    //申明全局函数作友元，允许它访问私有保护成员
};

class derive : public ca { };    //ca类的派生类

void fun(ca& a) {        //作友元的函数要定义在那个类的后面
    a.id = "987";        //这是ca类的私有成员
    a.setName("xyz");    //这是ca类的保护成员
}

int main ( )
{
    ca a;
    //a.fun(...);    //友元函数不是当前类的成员函数，所以这句编译出错
    fun(a);
    a.print();

    derive d;
    fun(d);    //作参数时，类型转换为ca类
    d.print();

    return 0;
}

别的类的成员函数作友元，也就是说这2个类相互调用，这样无论谁定义在前在后，编译时都有冲突。要解决这个问题，只要将类的申明、定义、实装分开就可以了。请注意例子中的解说。

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

class ca;    //事先申明ca类，确保cb类的定义不出错

class cb {    //在ca类之前定义cb类，确保在ca类里申明cb的test()作友元时不出错
public:
    void test(ca& a);    //由于ca类事先申明，这儿不出错
};

class ca {
    string id;
    void setId(string s) {
        id = s;
    }
protected:
    string name;
    void setName(string s) {
        name = s;
    }
public:
    void print() {
        cout << id << "  " << name << "  " << endl;
    }
    friend void cb::test(ca& a);    //申明cb类的test()函数作友元，允许它访问私有保护成员
};

void cb::test(ca& a) {  //作友元的成员函数的实装必须在ca类的后面，否则ca类的成员就未定义了。
    a.id = "123";        //这是ca类的私有成员
    a.setName("abc");    //这是ca类的保护成员
}

int main ( )
{
    ca a;
    cb b;
    b.test(a);
    a.print();

    return 0;
}

下面将上一章最后一个例子稍作修改，操作符重载由类的函数改为全局函数，也就是说，这个运算符不是这个类的，而是正常使用的操作符。注意重载函数的写法与上一章略有不同。不过，改为友元方式其实并没有必要，纯粹是为了讲解“友元”的用法。

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

class rect {
    int x1, y1, x2, y2;    //矩形座标
public:
    rect() {
        x1 = 0, y1 = 0, x2 = 0, y2 = 0;
    }
    rect(int m1, int n1, int m2, int n2) {
        x1 = m1, y1 = n1, x2 = m2, y2 = n2;
    }
    void print() {
        cout << "  x1=" << x1;
        cout << "  y1=" << y1;
        cout << "  x2=" << x2;
        cout << "  y2=" << y2;
        cout << endl;
    }
    //rect operator++();                 //这是类的运算符的重载
    friend rect operator++(rect &ob);   //这是全局运算符的重载
};

rect operator++(rect &ob) {
    ob.x1++, ob.y1++; 
    ob.x2++, ob.y2++;

    return ob;
}

int main ( )
{
    rect r(12, 20, 50, 40);
    r.print();

    rect obj;
    obj = r++;
    obj.print();

    return 0;
}

并不是所有操作符都可以定义成“友元”，例如“=”就不能用“友元”方式重载。