首页 > 编程语言 > 详细

C++友元函数和友元类（C++ friend关键字）

时间：2021-04-22 15:46:46      阅读：28      评论：0      收藏：0      [点我收藏+]

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]

 

C++友元函数和友元类（C++ friend关键字）

原文：https://www.cnblogs.com/rsapaper/p/14689090.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
分享档案
更多>
2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)
最新文章
更多>
教程昨日排行
更多>
友情链接
汇智网   PHP教程   插件网  
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣，分享程序人生！