上一讲中鸡啄米讲了类的静态成员，这一讲来讲下最后一种共享数据方式--友元。友元是一种破坏类的封装性获取类的隐藏数据的方式。

       如果有以下程序：

         class A
        {
         public:
                    int Getx()   { return x; }
         private:
                    int x;
         };
        class B
        {
        public:
                    void Set(int y);
        private:
                    A a;
        };

       上面就是类的组合的形式。类B中包含一个类A的对象作为数据成员。但是类B的成员函数不能直接访问类A的私有数据成员x。比如下面类B的成员函数Set的实现是不正确的：

       void B::Set(int y)
       {
                a.x = y;
       }

       那么怎样实现B的成员函数直接访问A的数据成员呢？C++提供了友元机制。

       通过友元的方式，某个普通函数或者类的成员函数可以访问某个类中的私有数据，这样就等于在类的封装的很好的外衣上剪开了一个小洞，外界可以通过这个小洞访问到一些类内部的数据。友元提供了一种不同类或对象的成员函数之间、类的成员函数与普通函数之间共享数据的机制。它破坏了类的封装性和类数据的隐藏性，但是又给我们进行软件开发提供了很多方便，在我们实地进行软件开发的时候可以自己在共享和封装之间平衡一下，决定是否选择使用友元，鸡啄米认为，原则上尽量少使用或不使用友元，除非确实很大的提高了开发效率。

       在一个类中声明友元的方式是，用关键字friend把普通函数、其他类的成员函数或其他类声明为此类的友元，用friend声明的元素就可以访问此类的私有数据。如果友元是普通函数或是类的成员函数就叫做友元函数，如果友元是一个类则叫做友元类，友元类的所有成员函数均为友元函数。

      1.友元函数

       友元函数是在类的声明中用关键字friend修饰的普通函数或者其他类的成员函数。友元函数虽不是本类的成员函数，但在它的函数体中可以访问该类对象的私有成员和保护成员。鸡啄米给大家看个例子：

       #include <iostream>
       #include <math.h>
       using namespace std;
       class Data //Data类声明
       { 
       public:      //外部接口
                  Data(int xx=0) { x=xx; }
                  int GetX() { return x; }
                  friend int Add(Data &a, Data &b); 
       private: //私有数据成员
                  int x;
       };
       int Add(Data &a, Data &b)
       {
                  return a.x + b.x;
       }
       int main()
       { 
                 Data a(1);
                 Data b(2);
                 int sum = Add(a, b);
                 cout<<"The sum is "<<sum<<endl;
                 return 0;
       }

       程序运行结果是：The sun is 3

       在Data类中声明友元函数Add时只给出了友元函数原型，友元函数Add的实现在类Data外。我们看到，在Add函数体中直接通过对象名访问了Data类的私有成员x，这就是友元的强大作用。我们在类外用一般方式访问x的话必须通过公共接口GetX来实现，若要访问的私有成员很多或者要访问的地方很多就要多次调用函数，对于我们写代码和程序运行都有效率上的损失，但是用友元也有个很大的缺点就是，如果私有数据x发生结构性的变化，那么友元函数就要做相应的修改，所有调用友元函数的地方可能也要修改，这就降低了开发效率，所以是否要使用友元可以自己权衡。

       上面例子中的友元函数是普通函数，这个函数也可以是其他类的成员函数，用法类似。

       2.友元类

       类也可以声明为另一个类的友元，就像友元函数那样，这个作为另一个类的友元的类就叫做友元类。如果一个类B是类A的友元类，则类B的所有成员函数都是类A的友元函数，都能访问类A的私有成员和保护成员。友元类的声明形式为：

        class A
        {
                 ...
                 friend class B;   // 将类B声明为类A的友元类
                 ...
        }

       上面声明中，类B是类A的友元类，B的成员函数可以访问类A的对象的私有成员和保护成员。鸡啄米再让大家看看友元类的使用：

       class A
       {   
       public:
                   void Display()   { cout<<x<<endl;}
                   friend class B;
       private:
                   int x;
       }
       class B
       {   
       public:
                   void Set(int i);
                   void Display();
       private:
                   A a;
       };
       void B::Set(int i)
       {
                  a.x=i;         // 因为类B是类A的友元类，所以类B的成员函数可以访问类A对象的私有成员
       }
       void B::Display()
       {
                 a.Display();
       }

       鸡啄米提醒大家，友元关系不能传递，如果类B是类A的友元，类C又是类B的友元，类C和类A如果没有声明则没有友元关系，另外，友元关系是单向的，如果类B是类A的友元，类B的成员函数可以访问类A对象的私有成员和保护成员，但是类A的成员函数不能访问类B对象的私有成员和保护成员。

       友元的知识大概就这些了，大家在使用的时候要综合考虑封装和共享之间的平衡，鸡啄米认为还是要尽量少使用友元。