友元

友元提供了不同类的成员函数之间、类的成员函数与一般函数之间进行数据共享的机制。通过友元，一个不同函数或另一个类中的成员函数可以访问类中的私有成员和保护成员。c++中的友元为封装隐藏这堵不透明的墙开了一个小孔，外界可以通过这个小孔窥视内部的秘密。
友元的正确使用能提高程序的运行效率，但同时也破坏了类的封装性和数据的隐藏性，导致程序可维护性变差。
应用实例
下面举一例子说明友元函数的应用。   
#include<iostream>
#include<cmath>
using namespace std;
class Point
{
public:
    Point(double xx, double yy)
    {
        x = xx;
        y = yy;
    };
    void Getxy();
    friend double Distance(Point &a, Point &b);
private:
    double x, y;
};
void Point::Getxy()
{
    cout << "(" << x << "," << y << ")" << endl;
}
double Distance(Point &a, Point &b)
{
    double dx = a.x - b.x;
    double dy = a.y - b.y;
    return sqrt(dx*dx + dy*dy);
}
int main(void)
{
    Point p1(3.0, 4.0), p2(6.0, 8.0);
    p1.Getxy();
    p2.Getxy();
    double d = Distance(p1, p2);
    cout << "Distance is" << d << endl;
    return 0;

}

友元除了前面讲过的函数以外，友元还可以是类，即一个类可以作另一个类的友元。当一个类作为另一个类的友元时，这就意味着这个类的所有成员函数都是另一个类的友元函数。
让我们回顾一下重载的“等于操作符的”定义，它是为名字空间域中定义的String 类而提供的，针对两个String 对象的“等于操作符”如下：
    
booloperator==(constString&str1,constString&str2)
{
if(str1.size()!=str2.size())
returnfalse;
returnstrcmp(str1.c_str(),str2.c_str())?false:true;
}
把这个定义与被定义为成员函数的操作符定义相比较：
    
boolString::operator==(constString&rhs)const
{
if(_size!=rhs._size)
returnfalse;
returnstrcmp(_string,rhs._string)?false:true;
}
你看到区别了吗?我们注意到必须要修改函数定义内部对于String 类私有数据成员的引用方式。因为新的等于操作符是全局函数，不是类成员函数，它不能直接引用String 的私有数据成员，它使用访问成员函数size()和c_str()来获得String 对象的大小，以及底层的C 风格字符串。
另外一种可能的实现是把全局“等于操作符”声明为String 类的友元friend。通过把函数或操作符声明为友元，一个类可以授予这个函数或操作符访问其非公有成员的权利。
友元声明以关键字friend 开始，它只能出现在类定义中。因为友元不是授权类的成员，所以它不受其所在类的声明区域public private 和protected 的影响。这里我们选择把所有友元声明组织在一起并放在类头之后：
    
classString
{
friendbooloperator==(constString&,constString&);
friendbooloperator==(constchar*,constString&);
friendbooloperator==(constString&,constchar*);
public:
//...String类中的其他部分
};
String 类中的三个友元声明把全局域中声明的三个重载的“比较操作符”（在上节介绍）声明为String 类的友
元既然这些等于操作符已经被声明为友元那么它们的定义就可以直接引用String 的私有成员了。

//friend操作符直接引用String的私有成员
//friendoperators:refertoStringprivatemembersdirectly
booloperator==(constString&str1,constString&str2)
{
if(str1._size!=str2._size)
returnfalse;
returnstrcmp(str1._string,str2._string)?false:true;
}
inlinebooloperator==(constString&str,constchar*s)
{
returnstrcmp(str._string,s)?false:true;
}
//以下略
如何判断是类的友元
有人可能会说在这种情况下由于c_str()和size()是内联的它们提供了等价的效率，并且保留了成员封装所以没必要直接访问_size 和_string ，这是对的。使用成员访问函数而不是直接访问成员，并不总是意味着它的效率较低。由于存在这些访问函数，所以没有必要把等于操作符声明为String 类的友元。
那么我们怎样判断一个非类成员的操作符应该是类的友元还是应该使用成员访问函数呢？一般来说，类的实现者应该尽量使得名字空间函数和访问类内部表示的操作符的数目最小化。如果已经提供了访问成员函数并且它们具有等同的效率那么最好是使用这些成员函数，并且把名字空间操作符与类表示中的变化隔离开。但是如果类的实现者决定不为该类的某些私有成员提供访问成员函数，而且名字空间操作符需要引用这些私有成员才能完成它们的操作，那么就必须使用友元机制。
友元声明的最常见用法是允许非成员的重载操作符访问一个视其为朋友的类的私有成员。原因是除了提供左和右操作数的对称性外，可使非成员的重载操作符就像成员函数一样能够完全访问一个类的私有成员。
虽然友元声明的主要用处是在重载操作符上，但是在某些情况下一个名字空间函数，另一个在此之前被定义的类的成员函数或者一个完整的类必须声明为友元。
在使一个类成为另一个类的友元时，友元类的成员函数，被赋予访问授权类的非公有成员的权利。
下面我们将更详细地了解函数而不是操作符的友元声明。
一个类必须把它希望与之建立友元关系的重载函数集中的每个函数都声明为友元。
例如
   
externostream&storeOn(ostream&,Screen&);
externBitMap&storeOn(BitMap&,Screen&);
//...
classScreen
{
friendostream&storeOn(ostream&,Screen&);
friendBitMap&storeOn(BitMap&,Screen&);
//...
};
如果一个函数操纵两个不同类类型的对象而且该函数需要访问这两个类的非公有成员，则这个函数可以被声明为这两个类的友元，或者作为一个类的成员函数并声明为另一个类的友元让我们来看一看怎样做：
被声明两个类的友元声明
如果我们决定一个函数必须被声明为两个类的友元则友元声明如下
   
classWindow;//只声明
classScreen
{
friendboolis_equal(Screen&,Window&);
//...
};
classWindow
{
friendboolis_equal(Screen&,Window&);
//...
};
作为一个类的函数又是另一个类的友元
如果我们决定该函数必须作为一个类的成员函数并又是另一个类的友元，则成员函数声明和友元声明如下：
classWindow;
classScreen
{
public:
//copy是类Screen的成员
Screen&copy(Window&);
//...
};
classWindow
{
//copy是类Window的一个友元
friend Screen&Screen::copy(Window&);
//...
};
只有当一个类的定义已经被看到时它的成员函数才能被声明为另一个类的友元。这并不总是能够做到的。
例如如果Screen 类必须把Window 类的成员函数声明为友元，而Window类必须把Screen 类的成员函数声明为友元。该怎么办呢？在这种情况下可以把整个Window类声明为Screen 类的友元。
例如：
   
classWindow;
classScreen
{
friendclassWindow;
//...
};
Screen 类的非公有成员现在可以被Window 的每个成员函数访问。