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]