04 c++中的友元

c++中的类具有封装性，类中的私有数据只有该类的成员函数可以访问，程序中访问类中的私有成员，必须通过对象来调用成员函数，但是频繁的调用会使运行效率降低。

为了解决上述问题，c++中加入友元机制，友元可以不通过调用成员函数直接访问类的私有数据来提高运行效率。

友元可以是函数（友元函数）也可以是类（友元类）

友元函数：

• 类体内说明，加friend关键字，在类体外定义，定义格式和普通函数相同。
• 友元函数是非成员函数，调用上和普通函数相同。
• 友元函数可以直接访问类中私有成员。

全局或函数做友元函数：

 #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 ;
 }

类成员函数做友元函数：

 #include<iostream>
 #include<cmath>
 using namespace std;
 class Point;
 //前向声明,是⼀一种不完全型声明,即只需提供类名(⽆无需提供类实现)即可。仅可⽤用    于声明指针和引
 ⽤用。
 class ManagerPoint
 {
     public:
     double Distance(Point &a, Point &b);
 };
 class Point
 {
     public:
     Point(double xx, double yy)
     {
         x = xx;
         y = yy;
     }
     void Getxy();
     friend double ManagerPoint::Distance(Point &a, Point &b);
     private:
     double x, y;
 };
 void Point::Getxy()
 {
     cout << "(" << x << "," << y << ")" << endl;
 }
 double ManagerPoint::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();
     ManagerPoint mp;
     float d = mp.Distance(p1,p2);
     cout << "Distance is " << d<< endl;
     return ;
 }

友元类：

• 友元类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息
• 格式;friend class 友元类名
• 当说明一个类A是另一个类B的友元时，友元类A中所有成员函数都是另一个类B的友元函数

 #include <iostream>

 using namespace std;

 class X{
 public:
     friend class Y; //类Y 是类X 的友元类
     void set(int i) { x=i; }
     void display()
     {
         cout<<"x="<<x<<","<<"y="<<y<<endl;
     }
     private:
     int x;
     static int y; //静态数据说明
 };

 class Y
 {
     public:
         Y(int i,int j);
         void display();
     private:
         X a; //数据成员为类X的对象
 };

 int X::y=; //静态数据定义并初始化

 Y::Y(int i,int j)
 {
     a.x=i; X::y=j;
 }

 void Y::display()
 {
     cout<<"x="<<a.x<<","<<"y="<<X::y<<endl;
 }

 int main()
 {
     X b;
     b.set();
     b.display();
     Y c(,);
     c.display();
     b.display();
     return ;
 }

总结：

1. 友元虽然提高了代码的运行效率，但是他破坏了类的封装性。
2. 友元关系不可以被继承
3. 友元关系是单向的，没有交换性
4. 友元关系没有传递性