• C++学习——友元函数和友元类（friend关键字）

    以下内容源于C语言中文网的学习与整理，非原创，如有侵权请告知删除。

    在C++中，一个类中可以有 public、protected、private 三种属性的成员。通过这个类的对象可以访问 public 成员，只有本类中的函数可以访问本类的 private 成员。

    现在，我们来介绍一种例外情况——友元（friend）。

    借助友元，可以使得其他类中的成员函数以及全局范围内的函数访问当前类的 private 成员。

    friend 的意思是朋友，或者说是好友，与好友的关系显然要比一般人亲密一些。我们会对好朋友敞开心扉，倾诉自己的秘密，而对一般人会谨言慎行，潜意识里就自我保护。在 C++ 中，这种友好关系可以用 friend 关键字指明，中文多译为“友元”，借助友元可以访问与其有好友关系的类中的私有成员。如果你对“友元”这个名词不习惯，可以按原文 friend 理解为朋友。

    一、友元函数

    在当前类以外定义的、不属于当前类的函数（比如不属于任何类的非成员函数、其他类的成员函数）也可以在类中声明，但要在前面加 friend 关键字，这样的函数就叫做友元函数。

    友元函数可以访问当前类中的所有成员，包括 public、protected、private 属性的成员。

    1、将非成员函数声明为友元函数

    下面是一个“将非成员函数声明为友元函数”的例子：

    1. #include 
    2. using namespace std;
    3.  
    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. };
    14.  
    15. Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }
    16.  
    17. //非成员函数
    18. void show(Student *pstu){
    19.     cout<m_name<<"的年龄是 "<m_age<<"，成绩是 "<m_score<
    20. }
    21.  
    22. int main(){
    23.     Student stu("小明", 15, 90.6);
    24.     show(&stu);  //调用友元函数
    25.     Student *pstu = new Student("李磊", 16, 80.5);
    26.     show(pstu);  //调用友元函数
    27.  
    28.     return 0;
    29. }
    1. 小明的年龄是 15，成绩是 90.6
    2. 李磊的年龄是 16，成绩是 80.5

    （1）函数show() 是一个全局范围内的非成员函数，它不属于任何类。m_name、m_age、m_score 是 Student 类的 private 成员，原则上不能通过对象访问，但在 show() 函数中又必须使用这些 private 成员，所以将 show() 声明为 Student 类的友元函数。

    （2）友元函数不同于类的成员函数，在友元函数中不能直接访问类的成员，必须要借助对象。因此下面的写法是错误的：

    1. void show(){
    2.     cout<
    3. }

    成员函数在调用时会隐式地增加 this 指针，指向调用它的对象，从而使用该对象的成员；而 show() 是非成员函数，没有 this 指针，编译器不知道使用哪个对象的成员，要想明确这一点，就必须通过参数传递对象（可以直接传递对象，也可以传递对象指针或对象引用），并在访问成员时指明对象。 

    2、将其他类的成员函数声明为友元函数

    友元函数也可以是另外一个类的成员函数，请看下面的例子：

    1. #include 
    2. using namespace std;
    3.  
    4. class Address;  //提前声明Address类，因为Student类中show(Address *addr);的参数用到
    5.  
    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. };
    17.  
    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);//第27行
    28. };
    29.  
    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<
    34.     cout<<"家庭住址："<m_province<<"省"<m_city<<"市"<m_district<<"区"<
    35. }
    36.  
    37. //实现Address类
    38. Address::Address(char *province, char *city, char *district){
    39.     m_province = province;
    40.     m_city = city;
    41.     m_district = district;
    42. }
    43.  
    44. int main(){
    45.     Student stu("小明", 16, 95.5f);
    46.     Address addr("陕西", "西安", "雁塔");
    47.     stu.show(&addr);
    48.    
    49.     Student *pstu = new Student("李磊", 16, 80.5);
    50.     Address *paddr = new Address("河北", "衡水", "桃城");
    51.     pstu -> show(paddr);
    52.  
    53.     return 0;
    54. }
    1. 小明的年龄是 16，成绩是 95.5
    2. 家庭住址：陕西省西安市雁塔区
    3. 李磊的年龄是 16，成绩是 80.5
    4. 家庭住址：河北省衡水市桃城区

    （1）本例定义了两个类 Student 和 Address，程序第 27 行将 Student 类的成员函数 show() 声明为 Address 类的友元函数，由此，show() 就可以访问 Address 类的 private 成员变量了。

    （2）程序第 4 行对 Address 类进行了提前声明，是因为在 Address 类定义之前、在 Student 类中使用到了它，如果不提前声明，编译器会报错，提示'Address' has not been declared。类的提前声明和函数的提前声明是一个道理。

    （3）程序将 Student 类的声明和实现分开了，而将 Address 类的声明放在了中间，这是因为编译器从上到下编译代码，show() 函数体中用到了 Address 的成员 province、city、district，如果提前不知道 Address 的具体声明内容，就不能确定 Address 是否拥有该成员（类的声明中指明了类有哪些成员）。

    （4）这里简单介绍一下类的提前声明。一般情况下，类必须在正式声明之后才能使用；但是某些情况下（如上例所示），只要做好提前声明，也可以先使用。

    但是应当注意，类的提前声明的使用范围是有限的，只有在正式声明一个类以后才能用它去创建对象。如果在上面程序的第4行之后增加如下所示的一条语句，编译器就会报错：

    Address addr;  //企图使用不完整的类来创建对象

    因为创建对象时要为对象分配内存，在正式声明类之前，编译器无法确定应该为对象分配多大的内存。编译器只有在“见到”类的正式声明后（其实是见到成员变量），才能确定应该为对象预留多大的内存。在对一个类作了提前声明后，可以用该类的名字去定义指向该类型对象的指针变量（本例就定义了 Address 类的指针变量）或引用变量，因为指针变量和引用变量本身的大小是固定的，与它所指向的数据的大小无关。

    （5）一个函数可以被多个类声明为友元函数，这样就可以访问多个类中的 private 成员。

    二、友元类

    不仅可以将一个函数声明为一个类的“朋友”，还可以将整个类声明为另一个类的“朋友”，这就是友元类。

    友元类中的所有成员函数都是另外一个类的友元函数。

    将类 B 声明为类 A 的友元类，方法是在类A中的public下添加代码“friend class B”（有的编译器也可以不写 class 关键字，不过为了增强兼容性还是建议写上）。

    此时类 B 中的所有成员函数都是类 A 的友元函数，可以访问类 A 的所有属性的成员。

    比如更改上例的代码，将 Student 类声明为 Address 类的友元类：

    1. #include 
    2. using namespace std;
    3.  
    4. class Address;  //提前声明Address类
    5.  
    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. };
    17.  
    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. };
    30.  
    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<
    35.     cout<<"家庭住址："<m_province<<"省"<m_city<<"市"<m_district<<"区"<
    36. }
    37.  
    38. //实现Address类
    39. Address::Address(char *province, char *city, char *district){
    40.     m_province = province;
    41.     m_city = city;
    42.     m_district = district;
    43. }
    44.  
    45. int main(){
    46.     Student stu("小明", 16, 95.5f);
    47.     Address addr("陕西", "西安", "雁塔");
    48.     stu.show(&addr);
    49.    
    50.     Student *pstu = new Student("李磊", 16, 80.5);
    51.     Address *paddr = new Address("河北", "衡水", "桃城");
    52.     pstu -> show(paddr);
    53.  
    54.     return 0;
    55. }

    （1）友元的关系是单向的。如果声明了类 B 是类 A 的友元类，不等于类 A 是类 B 的友元类，类 A 中的成员函数不能访问类 B 中的 private 成员。

    （2）友元的关系不能传递。如果类 B 是类 A 的友元类，类 C 是类 B 的友元类，不等于类 C 是类 A 的友元类。

    （3）不建议把整个类声明为友元类，而只将某些成员函数声明为友元函数，这样更安全一些。

  • 相关阅读:
    解决Netty那些事儿之Reactor在Netty中的实现(创建篇)-上
    一些好玩的小游戏
    信息系统项目管理教程（第4版）：第二章 信息技术及其发展
    01-Python的基本概念
    我把 CPU 三级缓存的秘密，藏在这 8 张图里
    GFS 分布式文件系统
    【数模】典型相关分析
    centos密码过期导致navicat无法通过SSH登录阿里云RDS问题
    北邮22级信通院数电：Verilog-FPGA（6）第六周实验：全加器（关注我的uu们加群咯~）
    Nacos全面知识 ----微服务 SpringCloud
  • 原文地址：https://blog.csdn.net/oqqHuTu12345678/article/details/133827305