CPP-基础：友元

友元可以是一个函数，该函数被称为友元函数；友元也可以是一个类，该类被称为友元类。

我们已知道类具有封装和信息隐藏的特性。只有类的成员函数才能访问类的私有成员，程序中的其他函数是无法访问私有成员的。非成员函数可以访问类中的公有成员，但是如果将数据成员都定义为公有的，这又破坏了隐藏的特性。另外，应该看到在某些情况下，特别是在对某些成员函数多次调用时，由于参数传递，类型检查和安全性检查等都需要时间开销，而影响程序的运行效率。

为了解决上述问题，提出一种使用友元的方案。友元是一种定义在类外部的普通函数或类，但它需要在类体内进行说明，为了与该类的成员函数加以区别，在说明时前面加以关键字friend。友元不是成员函数，但是它可以访问类中的私有成员。友元的作用在于提高程序的运行效率，但是，它破坏了类的封装性和隐藏性，使得非成员函数可以访问类的私有成员。

一，友元函数

特点：

友元函数是能够访问类中的私有成员的非成员函数。友元函数从语法上看，它与普通函数一样，即在定义上和调用上与普通函数一样。

友元关系不具对称性。即 A 是 B 的友元，但 B 不一定是 A 的友元。 友元关系不具传递性。即 B 是 A 的友元，C 是 B 的友元，但是 C 不一定是 A 的友元。

 

应用实例

下面举一例子说明友元函数的应用。

 //---------------------------------------------------------------------------

 #pragma hdrstop

 //---------------------------------------------------------------------------

 #pragma argsused

 #include <iostream>
 #include <math.h>
 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(int argc, char* argv[])
 {
     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;

     system("pause");
     return ;
 }

说明：在该程序中的Point类中说明了一个友元函数Distance()，它在说明时前边加friend关键字，标识它不是成员函数，而是友元函数。它的定义方法与普通函数定义一样，而不同于成员函数的定义，因为它不需要指出所属的类。但是，它可以引用类中的私有成员，函数体中a.x，b.x，a.y，b.y都是类的私有成员，它们是通过对象引用的。在调用友元函数时，也是同普通函数的调用一样，不要像成员函数那样调用。本例中，p1.Getxy()和p2.Getxy()这是成员函数的调用，要用对象来表示。而Distance(p1, p2)是友元函数的调用，它直接调用，不需要对象表示，它的参数是对象。(该程序的功能是已知两点坐标，求出两点的距离。)

二，友元类

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

让我们回顾一下运算符重载的“等于操作符的”定义，它是为名字空间域中定义的String 类而提供的，针对两个String 对象的“等于操作符”如下：

 bool operator==( const String &str1, const String &str2 )
 {
     if ( str1.size() != str2.size() )
     return false;
     return strcmp( str1.c_str(), str2.c_str() ) ? false : true;
 }

把这个定义与被定义为成员函数的操作符定义相比较：

 bool String::operator==( const String &rhs ) const
 {
 　　if ( _size != rhs._size )
 　　return false;
 　　return strcmp( _string, rhs._string ) ? false : true;
 }

　　你看到区别了吗?我们注意到：必须要修改函数定义内部对于String 类私有数据成员的引用方式。因为新的等于操作符是全局函数，不是类成员函数，它不能直接引用String 的私有数据成员，它使用访问成员函数size()和c_str()来获得String 对象的大小，以及底层的C 风格字符串。

另外一种可能的实现是把全局“等于操作符”声明为String 类的友元friend。通过把函数或操作符声明为友元，一个类可以授予这个函数或操作符访问其非公有成员的权利。

友元声明以关键字friend 开始，它只能出现在类定义中。因为友元不是授权类的成员，所以它不受其所在类的声明区域public private 和protected 的影响。这里我们选择把所有友元声明组织在一起并放在类头之后：

 class String {
 　　friend bool operator==( const String &, const String & );
 　　friend bool operator==( const char *, const String & );
 　　friend bool operator==( const String &, const char * );
 　　public:
 　　// ... String 类中的其他部分
 };

String 类中的三个友元声明把全局域中声明的三个重载的“比较操作符”（在上节介绍）声明为String 类的友元既然这些等于操作符已经被声明为友元那么它们的定义就可以直接引用String 的私有成员了。

 // friend 操作符直接引用 String 的私有成员
 // friend operators: refer to String private members directly
 bool operator==( const String &str1, const String &str2 )
 {
 　　if ( str1._size != str2._size )
 　　return false;
 　　return strcmp( str1._string, str2._string ) ? false : true;
 }
 inline bool operator==( const String &str, const char *s )
 {
 　　return strcmp( str._string, s ) ? false : true;
 }
 // 以下略

如何判断是类的友元

　　有人可能会说在这种情况下由于c_str()和size()是内联的它们提供了等价的效率，并且保留了成员封装所以没必要直接访问_size 和_string ，这是对的。使用成员访问函数而不是直接访问成员，并不总是意味着它的效率较低。由于存在这些访问函数，所以没有必要把等于操作符声明为String 类的友元。

那么我们怎样判断一个非类成员的操作符应该是类的友元还是应该使用成员访问函数呢？一般来说，类的实现者应该尽量使得名字空间函数和访问类内部表示的操作符的数目最小化。如果已经提供了访问成员函数并且它们具有等同的效率那么最好是使用这些成员函数，并且把名字空间操作符与类表示中的变化隔离开。但是如果类的实现者决定不为该类的某些私有成员提供访问成员函数，而且名字空间操作符需要引用这些私有成员才能完成它们的操作，那么就必须使用友元机制。

友元声明的最常见用法是允许非成员的重载操作符访问一个视其为朋友的类的私有成员。原因是除了提供左和右操作数的对称性外，可使非成员的重载操作符就像成员函数一样能够完全访问一个类的私有成员。

虽然友元声明的主要用处是在重载操作符上，但是在某些情况下一个名字空间函数，另一个在此之前被定义的类的成员函数或者一个完整的类必须声明为友元。

在使一个类成为另一个类的友元时，友元类的成员函数，被赋予访问授权类的非公有成员的权利。

下面我们将更详细地了解函数而不是操作符的友元声明。

一个类必须把它希望与之建立友元关系的重载函数集中的每个函数都声明为友元。

例如

 extern ostream& storeOn( ostream &, Screen & );
 extern BitMap& storeOn( BitMap &, Screen & );
 // ...
 class Screen
 {
     friend ostream& storeOn( ostream &, Screen & );
     friend BitMap& storeOn( BitMap &, Screen & );
     // ...
 };

 extern ostream& storeOn( ostream &, Screen & );
 extern BitMap& storeOn( BitMap &, Screen & );
 // ...
 class Screen
 {
     friend ostream& storeOn( ostream &, Screen & );
     friend BitMap& storeOn( BitMap &, Screen & );
 　　 // ...
 };

如果一个函数操纵两个不同类类型的对象而且该函数需要访问这两个类的非公有成员，则这个函数可以被声明为这两个类的友元，或者作为一个类的成员函数并声明为另一个类的友元让我们来看一看怎样做：

被声明两个类的友元声明

如果我们决定一个函数必须被声明为两个类的友元则友元声明如下

 class Window; // 只声明
 class Screen {
 friend bool is_equal( Screen &, Window & );
 // ...
 };
 class Window {
 friend bool is_equal( Screen &, Window & );
 // ...
 };

作为一个类的函数又是另一个类的友元

如果我们决定该函数必须作为一个类的成员函数并又是另一个类的友元，则成员函数声明和友元声明如下：

 class Window;
 class Screen {
 public:
 // copy 是类 Screen 的成员
 Screen& copy( Window & );
 // ...
 };
 class Window {
 // copy 是类 Window 的一个友元
 friend Screen& Screen::copy( Window & );
 // ...
 };

只有当一个类的定义已经被看到时它的成员函数才能被声明为另一个类的友元。这并不总是能够做到的。

例如如果Screen 类必须把Window 类的成员函数声明为友元，而Window类必须把Screen 类的成员函数声明为友元。该怎么办呢？在这种情况下可以把整个Window类声明为Screen 类的友元。

例如：

 class Window;
 class Screen {
 friend class Window;
 // ...
 };

Screen 类的非公有成员现在可以被Window 的每个成员函数访问。