友元 
 
 
一般来说，类内的私有数据是对外不可见的，但在有些情况下，我们需要在类外对该类的私有数据进行访问，这就需要用到一种新技术——友元（friend），即在声明前添加关键字friend。
 
友元关系是单向的，即如果A是B的友元，但B不一定是A的友元； 
 友元关系无传递性，即如果A是B的友元，B是C的友元，但A不一定是C的友元。
 
 
1. 友元函数
 
友元函数是指某些非类成员函数，但可以访问类内的私有数据。
 
#include <iostream>
using namespace std;

class A {
private:
    int data;
public:
    A() : data(1) {}
    friend void show( const A& t );  //添加friend定义友元函数
};  

/* 友元函数在类外声明时不加friend */
void show( const A& t ) {
    cout << "data = " << t.data << endl;  
}

int main(void) {  
    A a;
    show(a);  

    return 0;  
}

/*

运行结果：
data = 1

*/
 
 
2. 友元类
 
友元类是指若需要在类B中直接访问类A的私有数据，因此将B作为A的友元（在A中声明friend class B;）。 
 友元类中的成员函数、私有数据都可以在另一个类中被使用（即类B中可以直接使用类A的私有数据等）
 
class Tv {
private: 
    int state;
public: 
    friend class Remote;  //声明Remote为Tv的友元类
    enum{ Off, On };

    Tv( int s = Off ) : state(s) {}
    void onoff() { state = (state == On) ? Off : On; }
};

class Remote {
public: 
    void onoff( Tv & t ) { t.onoff(); }
};
 
 
3. 友元成员函数
 
友元成员函数是指类中的一个成员函数被定义为友元函数。 
 与友元类不同的是，只有友元成员函数可以在另一个中被使用，其余函数都不可以。
 
#include <iostream>
using namespace std;

class B;  //前向声明

class A{
private: 
    int a;
public: 
    A() { a = 1; }
    void print( B & b );
};

/* 示例位置1 */

class B{
private: 
    int b;
public: 
    B() { b = 6; }
    void print() { cout << b << endl; }
    friend void A::print( B & b );  //友元成员函数
};

/* 被定义为友元成员函数的函数必须在类外（另一个使用该函数的类后面）定义 */
void A::print( B & b ) {
    cout << "b = " << b.b << endl;
}

int main() {
    A a;
    B b;
    a.print( b );

    return 0;
}

/*

输出结果:
b = 6

*/
 
需要注意的是： 
 （1）类的前向声明。由于在A中的print函数需要使用B，如果不进行B的前向声明，编译器就不知道B是一个类，会报错。 
 （2）类的排列顺序。在类B中会用到A的方法print()，因此需要先定义A，再定义B。 
 （3）友元成员函数的定义位置。友元成员函数不能使用内联代码，类中只能有函数声明。函数定义需要放到类之后，在类外进行定义，而且必须放到另一个类定义的后面。（对上面代码来说，若将A::print()的定义放在类B定义之前——示例位置1处，也会报错，提示类B未完成）
 
对于友元的位置在何处生明，可以简单记为friend在哪，哪个就可以被外面直接访问。（friend在类A，A就可以被其他特定位置访问）

一、一个类的成员函数有三个互不相干作用
 
1.可以通过类的成员方法，访问它的私有数据。
 
        2.该函数的作用域在类中。
 
        3.在外部调动该函数必须通过成员访问符访问，也就是必须经由一个对象去激活（有一个this指针）。
 
二、友元函数
 
1.友元函数作用域不属于类的作用域，不是类的成员，也就不是类的方法，不受公有、私有、保护限制。
 
2.友元函数可以在类中实现，也可以在类外实现（一般是在类的外部实现）。
 
3，声明成友元函数，可以通过友元函数实现对类的私有数据进项访问。（但是他没有this指针）
 
4.一般友元函数声明在类的最前面
 
5.友元函数是为另外一个类的成员方法，则其作用域为另外一个类的作用域。
 
6.友元类，在一个类中声明为友元类，则该友元类都可以访问他的私有数据
 
 
在类的外部实现，也可以在内部实现
 
 
三、输出运算符<<、输入运算符>>的重载
 
我们平时可以用流 std::cout<<str<<n ; std::cin>>str>>n ; 输出、输入字符串和整型等内置类型的值。但是对于我们自定义的类，比如 Student 类，却不能直接通过 cout<<Student 或 cin>>Student 这样的形式来输出类的内容或给类赋值。怎么办呢？我们可以通过重载输出、输入运算符，让自定义的类也支持这样的操作。
 
1.在引入iostream头文件，标准的命名空间的后，ostream 输出流(类)，其中cout是它的一个对象， istream输入流对象，cin是它的一个对象。
 
2.输入输出流对象一般只是对内置类型进行输出，对对象的输出要进行运算符的重载
 
3.输入、输出运算符的重载，一般通过友元函数，进行实现，友元函数可以访问一个类的私有数据，通过友元函数可以实现对类的输出；
 
 
       在类中声明成友元函数才能访问私有数据
 
 
   这样的话调动cout<<c<<endl;就可以对对象进行输出
 
4.输入输出运算符的重载也可以是类的成员方法，在类的内部实现，只不过输出格式比较诡异通过类的对象调动cout对象 c<<cout;
 

1、为什么需要把需要把运算符重载为友元函数？
 运算符重载，如果重载为类的成员函数能解决问题的话最好。但是有些情况下，将运算符重载为成员函数并不能有效的解决问题，这个时候考虑将运算符重载为全局函数。但是将运算符重载为全局函数也有一些不足。遇到这种情况的一种策略就是把运算符重载为友元函数。
 
Complex x，y；
y=x+5；//情况一
y=5+x；//情况二
 
情况一
 这种情况将加号运算符重载为Complex类的成员函数没有问题。x+5等价于x.operator+(5)。
情况二
 这种情况如果将加号运算符重载为Complex类的成员函数不会发起符号函数的调用，但是如果将加号重载为全局函数，全局函数内部又无法访问到x对象的数据。此时考虑将该全局函数生命为Complex类的友元函数。
 
2、什么情况下需要将运算符重载为友元函数？
 
情况一
 对双目运算符进行的重载，运算符左侧运算对象不能够发起运算符重载函数的调用(左侧运算对象的类型与右侧不匹配，但是定义运算符函数属于右侧类类型的成员函数 ，因此无法发起函数调用。)，此时应该重新写一个全局的运算符重载函数，并在该类中将此方法声明为友元函数。
其它情况
 (遇到后再做记录。)

一、类中成员函数作用
 
可以通过类的成员方法，访问它的私有数据。
该函数的作用域在类中。
在外部调动该函数必须通过成员访问符访问，也就是必须经由一个对象去激活（有一个this指针）。
二、友元函数
 
特点
 
友元函数是类的辅助手段，友元能够引用类中本来被隐蔽的信息。
使用友元的目的是基于程序的运行效率。
一般运算符重载和两个类共享数据这两个场合需要使用友元。
友元可以是函数，也可以是类，在一个类中声明为友元类，则该友元类都可以访问他的私有数据。
友元是非传递的。
友元函数作用域不属于类的作用域，不是类的成员，也就不是类的方法，不受公有、私有、保护限制。
友元函数可以在类中实现，也可以在类外实现（一般是在类的外部实现）。
优缺点
 
优点：能够提高效率，表达简单、清晰。
缺点：友元函数破环了封装机制，尽量不使用成员函数，除非不得已的情况下才使用友元函数
参数
 
因为友元函数没有this指针，则参数要有三种情况：
 
要访问非static成员时，需要对象做参数；
要访问static成员或全局变量时，则不需要对象做参数；
如果做参数的对象是全局对象，则不需要对象做参数；
三、举例说明
 
 
 
#include<iostream>
using namespace std;
class A{
private://友元函数作用域不属于类的作用域，不是类的成员，也就不是类的方法，不受公有、私有、保护限制。
	int i;
	friend void FriendFun(A *,int);
public:
	void MemberFun(int);
}; 
void FriendFun(A *ptr,int x)
{
	ptr->i=x;//友元函数通过对象参数访问私有数据成员 
}
void A::MemberFun(int x)
{
	i=x;//成员函数通过this指针在对象上操作 
}
int main()
{
	A Aobj;
	FriendFun(&Aobj,5);
	Aobj.MemberFun(5);
	
	return 0;
}