C/C++教程

c++友元函数和友元类

本文主要是介绍c++友元函数和友元类,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

在 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;
  3. class Student{
  4. public:
  5. Student(char *name, int age, float score);
  6. public:
  7. friend void show(Student *pstu); //将show()声明为友元函数
  8. private:
  9. char *m_name;
  10. int m_age;
  11. float m_score;
  12. };
  13. Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }
  14. //非成员函数
  15. void show(Student *pstu){
  16. cout<<pstu->m_name<<"的年龄是 "<<pstu->m_age<<",成绩是 "<<pstu->m_score<<endl;
  17. }
  18. int main(){
  19. Student stu("小明", 15, 90.6);
  20. show(&stu); //调用友元函数
  21. Student *pstu = new Student("李磊", 16, 80.5);
  22. show(pstu); //调用友元函数
  23. return 0;
  24. }

运行结果:
小明的年龄是 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;
  3. class Address; //提前声明Address类
  4. //声明Student类
  5. class Student{
  6. public:
  7. Student(char *name, int age, float score);
  8. public:
  9. void show(Address *addr);
  10. private:
  11. char *m_name;
  12. int m_age;
  13. float m_score;
  14. };
  15. //声明Address类
  16. class Address{
  17. private:
  18. char *m_province; //省份
  19. char *m_city; //城市
  20. char *m_district; //区(市区)
  21. public:
  22. Address(char *province, char *city, char *district);
  23. //将Student类中的成员函数show()声明为友元函数
  24. friend void Student::show(Address *addr);
  25. };
  26. //实现Student类
  27. Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }
  28. void Student::show(Address *addr){
  29. cout<<m_name<<"的年龄是 "<<m_age<<",成绩是 "<<m_score<<endl;
  30. cout<<"家庭住址:"<<addr->m_province<<"省"<<addr->m_city<<"市"<<addr->m_district<<"区"<<endl;
  31. }
  32. //实现Address类
  33. Address::Address(char *province, char *city, char *district){
  34. m_province = province;
  35. m_city = city;
  36. m_district = district;
  37. }
  38. int main(){
  39. Student stu("小明", 16, 95.5f);
  40. Address addr("陕西", "西安", "雁塔");
  41. stu.show(&addr);
  42. Student *pstu = new Student("李磊", 16, 80.5);
  43. Address *paddr = new Address("河北", "衡水", "桃城");
  44. pstu -> show(paddr);
  45. return 0;
  46. }

运行结果:
小明的年龄是 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;
  3. class Address; //提前声明Address类
  4. //声明Student类
  5. class Student{
  6. public:
  7. Student(char *name, int age, float score);
  8. public:
  9. void show(Address *addr);
  10. private:
  11. char *m_name;
  12. int m_age;
  13. float m_score;
  14. };
  15. //声明Address类
  16. class Address{
  17. public:
  18. Address(char *province, char *city, char *district);
  19. public:
  20. //将Student类声明为Address类的友元类
  21. friend class Student;
  22. private:
  23. char *m_province; //省份
  24. char *m_city; //城市
  25. char *m_district; //区(市区)
  26. };
  27. //实现Student类
  28. Student::Student(char *name, int age, float score): m_name(name), m_age(age), m_score(score){ }
  29. void Student::show(Address *addr){
  30. cout<<m_name<<"的年龄是 "<<m_age<<",成绩是 "<<m_score<<endl;
  31. cout<<"家庭住址:"<<addr->m_province<<"省"<<addr->m_city<<"市"<<addr->m_district<<"区"<<endl;
  32. }
  33. //实现Address类
  34. Address::Address(char *province, char *city, char *district){
  35. m_province = province;
  36. m_city = city;
  37. m_district = district;
  38. }
  39. int main(){
  40. Student stu("小明", 16, 95.5f);
  41. Address addr("陕西", "西安", "雁塔");
  42. stu.show(&addr);
  43. Student *pstu = new Student("李磊", 16, 80.5);
  44. Address *paddr = new Address("河北", "衡水", "桃城");
  45. pstu -> show(paddr);
  46. return 0;
  47. }

第 24 行代码将 Student 类声明为 Address 类的友元类,声明语句为:

friend class Student;

有的编译器也可以不写 class 关键字,不过为了增强兼容性还是建议写上。

关于友元,有两点需要说明:

  • 友元的关系是单向的而不是双向的。如果声明了类 B 是类 A 的友元类,不等于类 A 是类 B 的友元类,类 A 中的成员函数不能访问类 B 中的 private 成员。
  • 友元的关系不能传递。如果类 B 是类 A 的友元类,类 C 是类 B 的友元类,不等于类 C 是类 A 的友元类。


除非有必要,一般不建议把整个类声明为友元类,而只将某些成员函数声明为友元函数,这样更安全一些。

这篇关于c++友元函数和友元类的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!