1，友元函式的定義和作用

我們已知道類具有封裝和資訊隱藏的特性。只有類的成員函式才能訪問類的私有成員，程式中的其他函式是無法訪問私有成員的。非成員函式可以訪問類中的公有成員，但是如果將資料成員都定義為公有的，這又破壞了隱藏的特性。另外，應該看到在某些情況下，特別是在對某些成員函式多次呼叫時，由於引數傳遞，型別檢查和安全性檢查等都需要時間開銷，而影響程式的執行效率。

為了解決上述問題，提出一種使用友元的方案。友元是一種定義在類外部的普通函式，但它需要在類體內進行說明，為了與該類的成員函式加以區別，在說明時前面加以關鍵字friend。友元不是成員函式，但是它可以訪問類中的私有成員。友元的作用在於提高程式的執行效率（即減少了型別檢查和安全性檢查等都需要的時間開銷），但是，它破壞了類的封裝性和隱藏性，使得非成員函式可以訪問類的私有成員。

為什麼不能直接訪問呢？

先了解一下為什麼成員函式可以直接訪問成員變數？

成員函式能夠訪問類的成員變數是因為傳遞了指向當前物件的this指標，它如果訪問資料成員對其操作是this指向的物件的資料成員，是有實際意義的 。

友元函式不是成員函式，沒有傳遞隱藏的this指標，只能間接訪問。

這點其實和靜態成員函式一樣，靜態成員函式也是沒有this指標的，所以它只能訪問靜態成員變數或者通過物件訪問非靜態成員變數。

例子：

class Rect  
{  
public:  
	Rect()      // 建構函式，計數器加1  
	{  
		count++;  
	}  
	//Rect(const Rect& r)
	//{
	//	width = r.width;
	//	height = r.height;
	//	count++;
	//}
	~Rect()     // 解構函式，計數器減1  
	{  
		count--;  
	}  
	static int getCount()       // 返回計數器的值  
	{  
		return count;  
	} 
	friend int get();
private:  
	int width;  
	int height;  
	static int count;       // 一靜態成員做為計數器  
};  

int Rect::count = 0;        // 初始化計數器  
int get()
{
	return Rect::count;//友元函式通過類訪問私有靜態成員變數
}
int main()  
{  
	Rect rect1;  
	cout<<"The count of Rect: "<<Rect::getCount()<<endl;//通過類訪問公有靜態成員函式，輸出1  

	Rect rect2(rect1);   // 使用rect1複製rect2，此時應該有兩個物件  
	cout<<"The count of Rect: "<<Rect::getCount()<<endl; //輸出1
	cout << get() << endl;//輸出1
	//cout << Rect::count << endl;//不能編譯通過，不能訪問私有成員
	system("pause");
	return 0;  
}  
 

下邊轉載自：

http://blog.csdn.net/shandianling/article/details/7469361

C++ Primer中有如下描述：友元關係不能繼承。基類的友元對派生類的成員沒有特殊訪問
許可權。如果基類被授予友元關係，則只有基類具有特殊訪問許可權，該基類的派生類不能訪問授予友元關係的類。

 然而通過實踐發現，VS編譯器並沒有安裝上述描述來處理，下面的規則與上述描述相悖，卻符合VS編譯器的處理規則。

注：有待通過g++編譯器來驗證。

1 友元類的繼承問題

1.1 A類的友元B的派生類C 不能訪問A類的private或protect成員變數。但可以通過B提供的介面來訪問A。(廢話肯定可以)

1. #include <iostream> 
2. usingnamespace   std;   
3. class B;   
4. class A   
5. {   
6.     int a;   
7. public:   
8.     A(int x=0) { a=x; }   
9.     friendclass B;   
10. };   
11. class B   
12. {   
13.     int b;   
14. public:   
15.     void fun(A& ob){ cout << ob.a << endl;}   
16. };   
17. class C:public B  
18. {   
19. public:   
20.     //void fun2(A& ob){ cout <<ob.a <<endl;}   //派生類新加的函式卻不能訪問A，此句會報錯
21. };   
22. void   main()   
23. {   
24.     A a(55);   
25.     C c;   
26.     c.fun(a); //C是B的派生類   通過基類B的函式fun仍然可以訪問 
27. }   

1.2.  Base的友元可以通過Base的派生類Drived訪問Base的private，protect成員變數，但不能訪問Drived的private，protect成員變數。（這一點似乎與《C++ primer》裡說的有點衝突）

個人理解：Drived的物件本身就包含Base，Base的友元Frnd自然就可以訪問Base的部分。

1. #include <iostream> 
2. usingnamespace std;   
3. class Base   
4. {   
5.     int m_a;   
6. public:   
7.     Base(int x=0){ m_a=x; }   
8.     friendclass Frnd;   
9. };   
10. class Drived:public Base   
11. {   
12. private:  
13.     int m_c;  
14. public:   
15.     Drived(int x):Base(x){m_c=x;}   
16. };  
17. class Frnd   
18. {  
19. public:   
20.     void fun(Base& ob) { cout <<ob.m_a << endl; }   
21.     void fun2(Drived& ob)   
22.     {  
23.         cout << ob.m_a<<endl;  
24.         //cout <<ob.m_c<<endl; //編譯錯誤
25.     }   
26. };   
27. int main()   
28. {   
29.     Drived d(1);   
30.     Frnd f;   
31.     f.fun(d);   
32.     f.fun2(d);  
33.     system("pause");  
34.     return 0;  
35. }   

3 友元類的傳遞問題

A的友元是B，B的友元是C，那A的友元是C？　不是，友元類不具有傳遞性。