C++友元函數和友元類（C++ friend關鍵字）

C++友元函數和友元類（C++ friend關鍵字） http://c.biancheng.net/view/2233.html

在 C++ 中，一個類中可以有 public、protected、private 三種屬性的成員，通過對象可以訪問 public 成員，只有本類中的函數可以訪問本類的 private 成員。現在，我們來介紹一種例外情況——友元（friend）。借助友元（friend），可以使得其他類中的成員函數以及全局范圍內的函數訪問當前類的 private 成員。

friend 的意思是朋友，或者說是好友，與好友的關系顯然要比一般人親密一些。我們會對好朋友敞開心扉，傾訴自己的秘密，而對一般人會謹言慎行，潛意識里就自我保護。在 C++ 中，這種友好關系可以用 friend 關鍵字指明，中文多譯為“友元”，借助友元可以訪問與其有好友關系的類中的私有成員。如果你對“友元”這個名詞不習慣，可以按原文 friend 理解為朋友。

友元函數

在當前類以外定義的、不屬於當前類的函數也可以在類中聲明，但要在前面加 friend 關鍵字，這樣就構成了友元函數。友元函數可以是不屬於任何類的非成員函數，也可以是其他類的成員函數。

友元函數可以訪問當前類中的所有成員，包括 public、protected、private 屬性的。

1) 將非成員函數聲明為友元函數。

請大家直接看下面的例子：

1. #include <iostream>
2. using namespace std;
4. class Student{
5. public:
6. Student(char *name, int age, float score);
7. public:
8. friend void show(Student *pstu); //將show()聲明為友元函數
9. private:
10. char *m_name;
11. int m_age;
12. float m_score;
13. };
15. Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }
17. //非成員函數
18. void show(Student *pstu){
19. cout<<pstu->m_name<<"的年齡是 "<<pstu->m_age<<"，成績是 "<<pstu->m_score<<endl;
20. }
22. int main(){
23. Student stu("小明", 15, 90.6);
24. show(&stu); //調用友元函數
25. Student *pstu = new Student("李磊", 16, 80.5);
26. show(pstu); //調用友元函數
28. return 0;
29. }

運行結果：
小明的年齡是 15，成績是 90.6
李磊的年齡是 16，成績是 80.5

show() 是一個全局范圍內的非成員函數，它不屬於任何類，它的作用是輸出學生的信息。m_name、m_age、m_score 是 Student 類的 private 成員，原則上不能通過對象訪問，但在 show() 函數中又必須使用這些 private 成員，所以將 show() 聲明為 Student 類的友元函數。讀者可以親自測試一下，將上面程序中的第 8 行刪去，觀察編譯器的報錯信息。

注意，友元函數不同於類的成員函數，在友元函數中不能直接訪問類的成員，必須要借助對象。下面的寫法是錯誤的：

1. void show(){
2. cout<<m_name<<"的年齡是 "<<m_age<<"，成績是 "<<m_score<<endl;
3. }

成員函數在調用時會隱式地增加 this 指針，指向調用它的對象，從而使用該對象的成員；而 show() 是非成員函數，沒有 this 指針，編譯器不知道使用哪個對象的成員，要想明確這一點，就必須通過參數傳遞對象（可以直接傳遞對象，也可以傳遞對象指針或對象引用），並在訪問成員時指明對象。

2) 將其他類的成員函數聲明為友元函數

friend 函數不僅可以是全局函數（非成員函數），還可以是另外一個類的成員函數。請看下面的例子：

1. #include <iostream>
2. using namespace std;
4. class Address; //提前聲明Address類
6. //聲明Student類
7. class Student{
8. public:
9. Student(char *name, int age, float score);
10. public:
11. void show(Address *addr);
12. private:
13. char *m_name;
14. int m_age;
15. float m_score;
16. };
18. //聲明Address類
19. class Address{
20. private:
21. char *m_province; //省份
22. char *m_city; //城市
23. char *m_district; //區（市區）
24. public:
25. Address(char *province, char *city, char *district);
26. //將Student類中的成員函數show()聲明為友元函數
27. friend void Student::show(Address *addr);
28. };
30. //實現Student類
31. Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }
32. void Student::show(Address *addr){
33. cout<<m_name<<"的年齡是 "<<m_age<<"，成績是 "<<m_score<<endl;
34. cout<<"家庭住址："<<addr->m_province<<"省"<<addr->m_city<<"市"<<addr->m_district<<"區"<<endl;
35. }
37. //實現Address類
38. Address::Address(char *province, char *city, char *district){
39. m_province = province;
40. m_city = city;
41. m_district = district;
42. }
44. int main(){
45. Student stu("小明", 16, 95.5f);
46. Address addr("陝西", "西安", "雁塔");
47. stu.show(&addr);
49. Student *pstu = new Student("李磊", 16, 80.5);
50. Address *paddr = new Address("河北", "衡水", "桃城");
51. pstu -> show(paddr);
53. return 0;
54. }

運行結果：
小明的年齡是 16，成績是 95.5
家庭住址：陝西省西安市雁塔區
李磊的年齡是 16，成績是 80.5
家庭住址：河北省衡水市桃城區

本例定義了兩個類 Student 和 Address，程序第 27 行將 Student 類的成員函數 show() 聲明為 Address 類的友元函數，由此，show() 就可以訪問 Address 類的 private 成員變量了。

幾點注意：
① 程序第 4 行對 Address 類進行了提前聲明，是因為在 Address 類定義之前、在 Student 類中使用到了它，如果不提前聲明，編譯器會報錯，提示'Address' has not been declared。類的提前聲明和函數的提前聲明是一個道理。

② 程序將 Student 類的聲明和實現分開了，而將 Address 類的聲明放在了中間，這是因為編譯器從上到下編譯代碼，show() 函數體中用到了 Address 的成員 province、city、district，如果提前不知道 Address 的具體聲明內容，就不能確定 Address 是否擁有該成員（類的聲明中指明了類有哪些成員）。

這里簡單介紹一下類的提前聲明。一般情況下，類必須在正式聲明之后才能使用；但是某些情況下（如上例所示），只要做好提前聲明，也可以先使用。

但是應當注意，類的提前聲明的使用范圍是有限的，只有在正式聲明一個類以后才能用它去創建對象。如果在上面程序的第4行之后增加如下所示的一條語句，編譯器就會報錯：

Address addr;  //企圖使用不完整的類來創建對象

因為創建對象時要為對象分配內存，在正式聲明類之前，編譯器無法確定應該為對象分配多大的內存。編譯器只有在“見到”類的正式聲明后（其實是見到成員變量），才能確定應該為對象預留多大的內存。在對一個類作了提前聲明后，可以用該類的名字去定義指向該類型對象的指針變量（本例就定義了 Address 類的指針變量）或引用變量（后續會介紹引用），因為指針變量和引用變量本身的大小是固定的，與它所指向的數據的大小無關。

③ 一個函數可以被多個類聲明為友元函數，這樣就可以訪問多個類中的 private 成員。

友元類

不僅可以將一個函數聲明為一個類的“朋友”，還可以將整個類聲明為另一個類的“朋友”，這就是友元類。友元類中的所有成員函數都是另外一個類的友元函數。

例如將類 B 聲明為類 A 的友元類，那么類 B 中的所有成員函數都是類 A 的友元函數，可以訪問類 A 的所有成員，包括 public、protected、private 屬性的。

更改上例的代碼，將 Student 類聲明為 Address 類的友元類：

1. #include <iostream>
2. using namespace std;
4. class Address; //提前聲明Address類
6. //聲明Student類
7. class Student{
8. public:
9. Student(char *name, int age, float score);
10. public:
11. void show(Address *addr);
12. private:
13. char *m_name;
14. int m_age;
15. float m_score;
16. };
18. //聲明Address類
19. class Address{
20. public:
21. Address(char *province, char *city, char *district);
22. public:
23. //將Student類聲明為Address類的友元類
24. friend class Student;
25. private:
26. char *m_province; //省份
27. char *m_city; //城市
28. char *m_district; //區（市區）
29. };
31. //實現Student類
32. Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }
33. void Student::show(Address *addr){
34. cout<<m_name<<"的年齡是 "<<m_age<<"，成績是 "<<m_score<<endl;
35. cout<<"家庭住址："<<addr->m_province<<"省"<<addr->m_city<<"市"<<addr->m_district<<"區"<<endl;
36. }
38. //實現Address類
39. Address::Address(char *province, char *city, char *district){
40. m_province = province;
41. m_city = city;
42. m_district = district;
43. }
45. int main(){
46. Student stu("小明", 16, 95.5f);
47. Address addr("陝西", "西安", "雁塔");
48. stu.show(&addr);
50. Student *pstu = new Student("李磊", 16, 80.5);
51. Address *paddr = new Address("河北", "衡水", "桃城");
52. pstu -> show(paddr);
54. return 0;
55. }

第 24 行代碼將 Student 類聲明為 Address 類的友元類，聲明語句為：

friend class Student;

有的編譯器也可以不寫 class 關鍵字，不過為了增強兼容性還是建議寫上。

關於友元，有兩點需要說明：

• 友元的關系是單向的而不是雙向的。如果聲明了類 B 是類 A 的友元類，不等於類 A 是類 B 的友元類，類 A 中的成員函數不能訪問類 B 中的 private 成員。
• 友元的關系不能傳遞。如果類 B 是類 A 的友元類，類 C 是類 B 的友元類，不等於類 C 是類 A 的友元類。

除非有必要，一般不建議把整個類聲明為友元類，而只將某些成員函數聲明為友元函數，這樣更安全一些。

 

友元_百度百科 https://baike.baidu.com/item/%E5%8F%8B%E5%85%83

友元是一種定義在類外部的普通函數或類，但它需要在類體內進行說明，為了與該類的成員函數加以區別，在說明時前面加以關鍵字friend。友元不是成員函數，但是它可以訪問類中的私有成員。

 

 

中文名

友元

外文名

friend

目    的

提高程序的運行效率

性    質

定義在類外部的普通函數或類

學    科

計算機科學、測繪科學

缺    點

破壞了類的封裝性和隱藏性

目錄

1. 1 研究背景
2. 2 友元函數
3. ▪ 特點

1. ▪ 應用實例
2. 3 友元類
3. ▪ 定義

1. ▪ 注意事項
2. 4 問題

研究背景

編輯

類具有封裝和信息隱藏的特性。只有 類的成員函數才能訪問類的私有成員，程序中的其他函數是無法訪問私有成員的。非成員函數可以訪問類中的公有成員，但是如果將 數據成員都定義為公有的，這又破壞了隱藏的特性。另外，應該看到在某些情況下，特別是在對某些成員函數多次調用時，由於 參數傳遞，類型檢查和安全性檢查等都需要時間開銷，而影響程序的運行效率。  [1] 

為了解決上述問題，提出一種使用友元的方案。友元是一種定義在類外部的普通函數或類，但它需要在類體內進行說明，為了與該類的成員函數加以區別，在說明時前面加以關鍵字friend。友元不是成員函數，但是它可以訪問類中的私有成員。友元的作用在於提高程序的運行效率，但是，它破壞了類的封裝性和隱藏性，使得非成員函數可以訪問類的私有成員。不過，類的訪問權限確實在某些應用場合顯得有些呆板，從而容忍了友元這一特別語法現象。

友元函數

編輯

特點

友元函數是能夠訪問類中的私有成員的非成員函數。友元函數從語法上看，它與普通函數一樣，即在定義上和調用上與普通函數一樣。

友元關系不具對稱性。即 A 是 B 的友元，但 B 不一定是 A 的友元。 友元關系不具傳遞性。即 B 是 A 的友元，C 是 B 的友元，但是 C 不一定是 A 的友元。

應用實例

下面舉一例子說明 友元函數的應用。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

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

在該程序中的Point類中說明了一個 友元函數Distance()，它在說明時前邊加friend關鍵字，標識它不是成員函數，而是友元函數。它的定義方法與普通函數定義一樣，而不同於成員函數的定義，因為它不需要指出所屬的類。但是，它可以引用類中的私有成員， 函數體中a.x，b.x，a.y，b.y都是類的私有成員，它們是通過 對象引用的。在調用友元函數時，也是同普通函數的調用一樣，不要像成員函數那樣調用。本例中，p1.Getxy()和p2.Getxy()這是成員函數的調用，要用對象來表示。而Distance(p1, p2)是 友元函數的調用，它直接調用，不需要對象表示，它的參數是對象。(該程序的功能是已知兩點坐標，求出兩點的距離。)  [1] 

友元類

編輯

定義

友元除了函數以外，還可以是類，即一個類可以作另一個類的友元。當一個類作為另一個類的友元時，這就意味着這個類的所有成員函數都是另一個類的 友元函數，都可以訪問另一個類中的隱藏信息（包括私有成員和保護成員）。

定義友元類的語句格式如下：

friend class 類名（即友元類的類名）;

注意事項

(1) 友元關系不能被繼承。

(2) 友元關系是單向的，不具有交換性。若類B是類A的友元，類A不一定是類B的友元，要看在類中是否有相應的聲明。

(3) 友元關系不具有傳遞性。若類B是類A的友元，類C是B的友元，類C不一定是類A的友元，同樣要看類中是否有相應的申明。

問題

編輯

即一個函數作為一個類的函數，同時又是另一個類的友元。

如果我們決定該函數必須作為一個 類的成員函數，同時又是另一個類的友元，則成員函數聲明和友元聲明如下：

1 2 3 4 5 6

class  Window;       class  Screen {

1 2	public : //copy是類Screen的成員

1 2 3 4 5

Screen& copy(Window&); //...     };

1 2	class  Window {

1	//copy是類Window的一個友元

1 2	friend  Screen& Screen::copy(Window&); //...

1

只有當一個類的定義已經被定義時，它的成員函數才能被聲明為另一個類的友元。例如Screen 類必須把Window  類的成員函數聲明為友元，而Window類必須把Screen 類的成員函數聲明為友元。在這種情況下可以把整個Window類聲明為Screen 類的友元。  [2] 

1 2 3 4 5 6 7 8

class  Window;   class  Screen { friend  class  Window; //... };Screen 類的非公有成員可以被Window 的每個成員函數訪問。 Screen 類的非公有成員可以被Window 的每個成員函數訪問。

Screen 類的非公有成員可以被Window 的每個成員函數訪問。  [1]