cpp-友元

理解 C++ 中的友元（Friend）
在 C++ 语言中，封装（Encapsulation） 是面向对象编程的重要特性之一。它允许类将数据隐藏在私有（private）或受掩护（protected）成员中，防止外部直接访问。然而，在某些情况下，我们希望某些函数或类能够访问这些私有成员，而不粉碎封装性。这时，我们就需要友元（Friend）。

---

1. 什么是友元？

友元（friend） 是 C++ 提供的一种机制，它允许一个函数或另一个类访问某个类的私有和受掩护成员。友元有三种类型：

• 友元函数（Friend Function）
  
• 友元类（Friend Class）
  
• 友元成员函数（Friend Member Function）
  

---

2. 友元函数

友元函数是一个非成员函数，但它可以访问类的私有和受掩护成员。要声明友元函数，需要在类内部利用 friend 关键字。
示例：友元函数

1. #include <iostream>
2. using namespace std;
4. class Box {
5. private:
6.     double width;
8. public:
9.     Box(double w) : width(w) {}
10.    
11.     // 声明友元函数
12.     friend void printWidth(const Box &b);
13. };
15. // 定义友元函数
16. void printWidth(const Box &b) {
17.     cout << "Width: " << b.width << endl;
18. }
20. int main() {
21.     Box b(10.5);
22.     printWidth(b);
23.     return 0;
24. }

复制代码

在上面的示例中，printWidth 不是 Box 类的成员函数，但由于它被声明为 friend，它可以访问 Box 的私有成员 width。

---

3. 友元类

友元类允许一个类访问另一个类的私有和受掩护成员。
示例：友元类

1. #include <iostream>
2. using namespace std;
4. class Engine {
5. private:
6.     int horsepower;
8. public:
9.     Engine(int hp) : horsepower(hp) {}
10.    
11.     // 声明 Car 为友元类
12.     friend class Car;
13. };
15. class Car {
16. public:
17.     void showEnginePower(const Engine &e) {
18.         cout << "Engine horsepower: " << e.horsepower << endl;
19.     }
20. };
22. int main() {
23.     Engine e(150);
24.     Car c;
25.     c.showEnginePower(e);
26.     return 0;
27. }

复制代码

在这个例子中，Car 是 Engine 的友元类，因此它可以访问 Engine 类的私有成员 horsepower。

---

4. 友元成员函数

我们还可以只将另一个类的某个成员函数设为友元，而不是整个类。
示例：友元成员函数

1. #include <iostream>
2. using namespace std;
4. class Engine;
6. class Car {
7. public:
8.     void showEnginePower(const Engine &e);
9. };
11. class Engine {
12. private:
13.     int horsepower;
15. public:
16.     Engine(int hp) : horsepower(hp) {}
17.    
18.     // 声明 Car::showEnginePower 为友元
19.     friend void Car::showEnginePower(const Engine &e);
20. };
22. void Car::showEnginePower(const Engine &e) {
23.     cout << "Engine horsepower: " << e.horsepower << endl;
24. }
26. int main() {
27.     Engine e(200);
28.     Car c;
29.     c.showEnginePower(e);
30.     return 0;
31. }

复制代码

这里 Car::showEnginePower 是 Engine 的友元成员函数，因此它可以访问 Engine 的私有成员。

---

5. 友元的应用场景

友元在以下情况中非常有效：

• 运算符重载（如 operator<< 和 operator>> 需要访问类的私有成员）。
  
• 类之间的精密协作（如 Car 需要访问 Engine 的私有数据）。
  
• 全局函数需要访问私有数据（如调试函数、日志记录等）。
  

---

6. 友元的优缺点

优点：

• 允许外部函数/类访问私有数据，增强类之间的协作本领。
  
• 使操作符重载更加直观。
  

缺点：

• 粉碎了封装性，降低了数据的安全性。
  
• 可能导致代码耦合度增长。
  

---

7. 总结

• 友元函数 可以访问类的私有/受掩护成员，但不是类的成员。
  
• 友元类 允许另一个类访问本类的私有成员。
  
• 友元成员函数 允许一个类的特定成员函数访问本类的私有成员。
  
• 友元应该谨慎利用，制止粉碎封装性。
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。