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

C++ 友元函数和友元类 - 菜鸟教程 https://www.cainiaojc.com/cpp/cpp-friend-function-class.html

OOP的重要概念之一是数据隐藏，即非成员函数无法访问对象的私有或受保护的数据。

但是，有时这种限制可能迫使程序员编写冗长而复杂的代码。因此，C ++编程内置了一种机制，可以从非成员函数访问私有或受保护的数据。

这是使用友元函数和友元类完成的。

C ++中的友元函数

如果将函数定义为友元函数，则可以使用函数访问类的私有数据和受保护数据。

通过使用关键字friend，编译器知道给定的函数是友元函数。

要访问数据，应该在类的内部以关键字friend开始声明友元函数(可以是类内部的任何地方，可以是private部分，也可以是public部分)。

C ++中的友元函数声明

class class_name
{
    ... .. ...
    friend return_type function_name(argument/s);
    ... .. ...
}

现在，您可以将友元函数定义为访问该类数据的普通函数。friend定义中未使用任何关键字。

class className
{
    ... .. ...
    friend return_type functionName(argument/s);
    ... .. ...
}

return_type functionName(argument/s)
{
    ... .. ...
    // 可以从这个位置访问className的私有和受保护数据
     //因为此函数是className的友元函数。
    ... .. ...
}

示例1：友元函数的工作

/* C ++程序演示友元函数的工作。*/
#include <iostream>
using namespace std;

class Distance
{
    private:
        int meter;
    public:
        Distance(): meter(0) { }
        //友元函数
        friend int addFive(Distance);
};

// 友元函数的定义
int addFive(Distance d)
{
    //从非成员函数访问私有数据
    d.meter += 5;
    return d.meter;
}

int main()
{
    Distance D;
    cout<<"距离: "<< addFive(D);
    return 0;
}

输出结果

距离: 5

这里，友元函数addFive()在Distance类中声明。因此，可以从这个函数访问私有数据。

尽管此示例为您提供了有关友元函数概念的想法，但并未显示任何有意义的用途。

当您需要对两个不同类的对象进行操作时，将有一种更有意义的用法。那时，友元函数会非常有帮助。

你完全可以在不使用friend函数的情况下操作两个不同类的对象，但是这个程序会很长，很复杂，很难理解。

示例2：使用友元函数添加两个不同类的成员

#include <iostream>
using namespace std;

// 前置声明
class B;
class A {
    private:
      int numA;
    public:
      A(): numA(12) { }
      //友元函数声明
      friend int add(A, B);
};

class B {
    private:
       int numB;
    public:
       B(): numB(1) { }
       // 友元函数声明
       friend int add(A , B);
};

//函数add()是类A和B的友元函数
//访问成员变量numA和numB
int add(A objectA, B objectB)
{
   return (objectA.numA + objectB.numB);
}

int main()
{
    A objectA;
    B objectB;
    cout<<"Sum: "<< add(objectA, objectB);
    return 0;
}

输出结果

Sum: 13

在这个程序中，类A和B已经将add()声明为friend函数。因此，这个函数可以访问这两个类的私有数据。

在这里，add()函数将两个对象objectS和object的私有数据numA和numB相加，并将其返回给main函数。

为了使这个程序正常工作，应该像上面的实例中所示的那样，对一个类B进行前置声明。

这是因为使用以下代码在class A中引用了class B的友元函数：friend int add（A，B）;

C ++编程中的友元类(friend class)

类似地，像一个友元函数一样，一个类也可以使用关键字friend成为另一个类的友元类。例如:

... .. ...
class B;
class A
{
   // class B 是 class A的友元类
   friend class B;
   ... .. ...
}

class B
{
   ... .. ...
}

当一个类成为另一个类的friend类（友元类）时，这就意味着这个类的所有成员函数都是另一个类的友元函数。

在这个程序中，B类的所有成员函数都是A类的朋友函数，因此B类的任何成员函数都可以访问A类的私有和受保护的数据，但是A类的成员函数不能访问B类的数据。

C ++编程中如何互为友元类

如何实现classA与B互为友元，即A可以访问B的私有，B也可以访问A的私有呢？案例如下：

#include <iostream>

using namespace std;
//必须提前声明class B不然编译会报错
class B;
class A{
private:
    int a;
public:
    friend class B;

    A(){
        cout << "类A被构造" << endl;
        a = 20;
    }
    ~A(){
        cout << "类A被析构" << endl;
    }
    void show(B & b);
};

class B{
private:
    int b;
public:
    friend class A;
    B(){
        cout << "类B的构造" << endl;
        b = 12;
    }
    ~B(){
        cout << "类B被析构" << endl;
    }
    void show(A &a){
        cout << "a="<<a.a ;
        cout << " b=" <<b<<endl;
    }
};
//函数不能放在class A 中，不然会编译报错
void A::show(B &b){
    cout << "a="<<a ;
    cout << " b="<<b.b<< endl;
}

int main(){
    A a;
    B b;
    a.show(b);
    b.show(a);

    return 0;
}
运行结果：
类A被构造
类B的构造
a=20 b=12
a=20 b=12
类B被析构
类A被析构

互为友元类的做法就是，在class A中声明friend class B;在classB 中声明friend class A;

注意：类A中使用到了类B的地方必须在类B的声明后定义，在类A中只能声明。例如左边类A中的show函数，不能在类A中直接定义，只能放在类B的声明之后定义。

 

 

 

 

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]

 

posted @ 2021-04-22 12:52  papering  阅读(501)  评论(0)  编辑  收藏  举报