实例详解C++友元

       在说明什么是友元之前，先说明一下为什么需要友元与友元的缺点:
　　  通常对于普通函数来说,要访问类的保护成员是不可能的， 如果想这么做那么必须把类的成员都声明为public(共用的)，然而这做带来的问题遍是任何外部函数都可以毫无约束的访问它操作它们，
c++利用friend修饰符，可以让一些设定的函数能够对这些保护数据进行操作，避免把类成员全部设置成public，最大限度的保护数据成员的安全。
　　 友元能够使得普通函数直接访问类的保护数据，避免了类成员函数的频繁调用，可以节约处理器开销，提高程序的效率，但矛盾的是，即使是最大限度的保护，同样也破坏了类的封装特性，这就
是友元的缺点，在现在cpu速度越来越快的今天并不推荐使用它，但它作为c++一个必要的知识点，一个完整的组成部分，还是需要学习一下的。

　　在类里声明一个普通函数，在前面加上friend修饰，那么这个函数就成了该类的友元，可以访问该类的一切成员。

　　下面来看一段代码，看看是如何利用友元来访问类的一切成员的。

      #include <iostream>   
     

       using namespace std; 
       class Internet  {   
       public:   
         Internet(char *name,char *address) {   
                strcpy(Internet::name,name);   
                strcpy(Internet::address,address);    
        } 
        friend void ShowN(Internet &obj);  //友元函数的声明 
        protected:   
            char name[20]; 
            char address[20]; 
      }; 
 
 
       void ShowN(Internet &obj) {//函数定义,不能写成,void Internet::ShowN(Internet &obj)   
            cout<      }

 
      void main()  { 
            Internet a("爱立信中国研发中心",""); 
            ShowN(a); 
            cin.get(); 
     }

　 上面的代码通过友元函数的定义，成功的访问到了a对象的保护成员name,友元函数并不能看做是类的成员函数，它只是个被声明为类友元的普通函数，

所以在类外部函数的定义部分不能够写成void Internet::ShowN(Internet &obj)，这一点要注意。

    一个普通函数可以是多个类的友元函数，对上面的代码进行修改，注意观察变化：

    #include <iostream>   
    using namespace std; 
    class Country; 
    class Internet  {   
    public:   
        Internet(char *name,char *address) {   
            strcpy(Internet::name,name);   
            strcpy(Internet::address,address);    
        } 
        friend void ShowN(Internet &obj,Country &cn); //注意这里 
    public:   
        char name[20]; 
        char address[20]; 
    }; 
 
    class Country { 
    public: 
        Country() {strcpy(cname,"中国");} 
        friend void ShowN(Internet &obj,Country &cn);//注意这里 
    protected: 
        char cname[30]; 
    }; 
 
    void ShowN(Internet &obj,Country &cn)  { 
        cout<    }

     

    void main() { 
        Internet a("爱立信中国研发中心",""); 
        Country b; 
        ShowN(a,b); 
        cin.get(); 
    }

    一个类的成员函数函数也可以是另一个类的友元，从而可以使得一个类的成员函数可以操作另一个类的数据成员，在下面的代码中增加一类Country，注意观察：

    #include <iostream>   
    using namespace std; 
    class Internet; 
 
    class Country { 
    public: 
        Country()  {strcpy(cname,"中国"); } 
        void Editurl(Internet &temp);//成员函数的声明 
    protected: 
        char cname[30]; 
    }; 
    class Internet {   
    public:   
        Internet(char *name,char *address) {   
            strcpy(Internet::name,name);   
            strcpy(Internet::address,address);  
        } 
        friend void Country::Editurl(Internet &temp);//友元函数的声明 
    protected:   
        char name[20]; 
        char address[20]; 
    };

    void Country::Editurl(Internet &temp) {//成员函数的外部定义   
        strcpy(temp.address,"edu.cndev-lab.com"); 
        cout<    } 

    

    void main()  { 
        Internet a("爱立信中国研发中心","");
        Country b; 
        b.Editurl(a); 
        cin.get();      
    }

　整个类也可以是另一个类的友元，该友元也可以称做为友类。友类的每个成员函数都可以访问另一个类的所有成员。

    示例代码如下：

    #include <iostream>   
    using namespace std; 
    class Internet; 
 
    class Country  {     
    public: 
        Country()  { strcpy(cname,"中国"); } 
        friend class Internet;//友类的声明 
    protected: 
        char cname[30]; 
    }; 

    class Internet  { 
    public:   
        Internet(char *name,char *address)   {   
            strcpy(Internet::name,name);   
            strcpy(Internet::address,address);  
        } 
        void Editcname(Country &temp); 
    protected:   
        char name[20]; 
        char address[20]; 
    }; 
    void Internet::Editcname(Country &temp)  { 
        strcpy(temp.cname,"中华人民共和国");  
    }  

    void main()  { 
        Internet a("爱立信中国研发中心","");
        Country b; 
        a.Editcname(b); 
        cin.get(); 
    }

　在上面的代码中成功的通过Internet类Editcname成员函数操作了Country类的保护成员cname。

　在编程中，使用友元的另外一个重要原因是为了方便重载操作符的使用！