友元

•一般来说，类的私有成员只能在类的内部访问，类外的函数是不能访问它们的。

•但是，可以将一个函数定义为类的友元函数，这时该函数就可以访问该类的私有成员了。

•同时，也可以把另一个类B定义为本类A的友元类，这样B类就可以访问A类的任何成员了。

•下面来具体讨论友元函数和友元类的概念

>友元之非成员函数：

•在类的定义中用friend声明了一个外部函数或其他类的成员函数(public和private均可）后，这个外部函数称为类的友元函数。

•友元函数声明的基本格式为：

friend 函数原型;

•友元函数中可访问类的private成员。

•用下面的比喻形容友元函数可能比较恰当，将类比作一个家庭，类的private成员相当于家庭的秘密，一般的外人是不允许探听这些秘密的，只有friend（朋友）才有能力探听这些秘密。

•见代码

#include <cmath>	//使用计算平方根的函数sqrt要用到的头文件
#include <iostream>
using namespace std;

class Point										//Point类定义
{
private:
	int x, y;
	friend float dis(Point &p1, Point & p2);	//友元函数的声明，声明位置没有关系，可以是public，也可是private
	
public:
	Point(int i = 0, int j = 0)	//构造函数，带缺省参数值
	{
		x = i;
		y = j;
	}
	
	void disp()			//成员函数
	{
		cout << "(" << x << "," << y << ")";
	}
};

float dis(Point & p1, Point & p2)		//友元函数的实现
{
	//友元函数中可访问类的private成员
	float d = sqrt((p1.x - p2.x)*(p1.x - p2.x)+(p1.y - p2.y)*(p1.y - p2.y));
	return d;
}

int main()
{
	Point p1(1, 2), p2(4, 5);	//声明两个Point类的对象p1和p2
	p1.disp();			//显示点p1的信息
	
	cout << "与";
	p2.disp();			//显示点p2的信息
	
	cout << "距离=" << dis(p1, p2) << endl;	//利用友元函数计算两点举例
	
	return 0;
}

>友元之成员函数：

•A类的成员函数作为B类的友元函数时，必须先定义A类，而不仅仅是声明它。

•注意：将其他类的成员函数申明为本类的友元函数后，该友元函数并不能变成本类的成员函数。也就是说，朋友并不能变成家人。

•成员形式的友元函数见代码

•代码中，Line类的成员函数dis(…)的实现必须在类外进行，且必须在Point类的定义之后。因为其参数中包含了Point这种类型。

•Line类的dis()函数本来是不能访问Point.x和Pint.y这种Point类的private成员的，但在Point类中将dis()申明为友元函数后就能访问了。但dis()函数依然不是Point类的成员函数。也就是说，dis() 是Point类的朋友了,可以访问Point类的私有成员变量x和y了。

#include <cmath>		//使用计算平方根的函数sqrt要用到的头文件
#include<iostream>
#include <cmath>
using namespace std;

class Point;		//声明Point类

class Line			//定义Line类
{
public:
	float dis(Point& p1, Point& p2); 		//友元函数的原型，作为Line类的成员函数
};

class Point					//定义Point类
{
private:
	int x,y;				//private型数据成员x和y
	friend float Line::dis(Point &p1, Point &p2);	//友元的声明

public:
	Point(int i = 0, int j = 0)	//Point类的构造函数，带缺省参数
	{
		x = i;
		y = j;
	}

	void disp()			//成员函数disp()，用来输出点的信息
	{
		cout << "(" << x << "," << y << ")";
	}
};

//Line类内成员函数dis的实现，作为Point类的友元函数
float Line::dis(Point &p1, Point &p2)
{
	float d = sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));
	//可访问Point类对象的private成员

	return d;
}

int main()
{
	Line line1;			//声明一个Line类的对象line1
	Point p1(1,2), p2(4,5);		//声明两个Point类的对象p1和p2

	p1.disp();			//输出点p1的信息 
	cout << " 与 "; 
	p2.disp();			//输出点p2的信息

	cout << " 的距离 = " << line1.dis(p1, p2) << endl;
	//通过调用line1的成员函数dis计算两个点间的距离

	return 0;
}

>友元函数的重载

//要想使得一组重载函数全部成为类的友元，必须一一声明，否则只有匹配的那个函数会成为类的友元，编译器仍将其他的当成普通函数来处理。
class Exp
{
public:
firend void test(int); 	
};
void test();
void test(int);
void test(double);
//上述代码中，只有“void test(int)”函数是Exp类的友元函数，“void test()”和“void test(double)”函数都只是普通函数。

>友元类

•类A作为类B的友元时，类A称为友元类。A中的所有成员函数都是B的友元函数，都可以访问B中的所有成员。

•A可以在B的public部分或private部分进行声明，方法如下：

friend [class]<类名>; //友元类类名

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

class CLine;	//声明类CLine

class CPoint 	//定义CPoint类
{
private:
	int x, y;
	friend class CLine; //友元类的声明，位置同样不受限制
	
public:
	CPoint(int i = 0, int j = 0) //构造函数，带缺省参数值
	{
		x = i;
		y = j;
	}
	
	void disp() //成员函数，输出点的信息
	{
		cout << "(" << x << "," << y << ")";
	}
};

class CLine	//类CLine的定义，其中所有的函数都是CPoint类的友元函数
{
public:
	float dis(CPoint& p1,CPoint& p2)	//可访问p1和p2的private成员
	{
		float d;
		d=sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));
		return d;
	}

	void Set(CPoint* p1,int a,int b)		//可访问p1和p2的private成员
	{
		p1->x=a;
		p1->y=b;
	}
};

int main()
{
	CLine cz1;			//声明一个CLine类的对象cz1
	CPoint p1(1,2),p2(4,5);	//声明两个CPoint类对象p1和p2

	p1.disp();				//输出点p1的信息 
	cout<<"与";
	p2.disp();				//输出点p2的信息
	cout<<"距离="<<cz1.dis(p1,p2)<<endl;	//调用cz1的成员函数dis计算两点间距

	cz1.Set(&p1,3,4);		//调用cz1的成员函数Set改写p1中的private成员x和y
	p1.disp();			//修改后的点p1信息输出

	cout<<endl;		//换行

	return 0;
}

•不可否认，友元在一定程度上将类的私有成员暴露出来，破坏了信息隐藏机制，似乎是种“副作用很大的药”，但俗话说“良药苦口”，好工具总是要付出点代价的，拿把锋利的刀砍瓜切菜，总是要注意不要割到手指的。

•友元的存在，使得类的接口扩展更为灵活，使用友元进行运算符重载从概念上也更容易理解一些，而且，C++规则已经极力地将友元的使用限制在了一定范围内，它是单向的、不具备传递性、不能被继承，所以，应尽力合理使用友元。

•