在C++中，友元是一种特殊的关系，允许某个函数或类访问另一个类的私有成员和保护成员。友元打破了类的封装性，但也为实现一些复杂逻辑提供了便利。
下面，我会用详细解释和大量代码实例帮助你通俗易懂地理解友元函数、友元类、友元模板的概念和实际用途。
一、友元函数
友元函数是一种非成员函数，但它可以直接访问一个类的私有和保护成员。它是通过 friend 关键字声明的。
友元函数的特点：
- 友元函数不是类的成员，但可以访问类的私有和保护成员。
- 友元函数需要在类中声明，定义可以在类外。
- 友元关系是单向的，类给函数友元权限，但函数没有反向权限。
1.1 单个友元函数
我们通过一个简单的例子说明友元函数的工作原理：
代码实例：访问私有成员
#include <iostream>
using namespace std;class Box {
private:double length; // 私有成员变量
public:Box(double l) : length(l) {}// 声明友元函数friend double getLength(const Box& b);
};// 友元函数的定义
double getLength(const Box& b) {return b.length; // 可以直接访问 Box 的私有成员
}int main() {Box box(10.5);cout << "Length of the box: " << getLength(box) << endl;return 0;
}
输出：
Length of the box: 10.5
解释：
getLength是Box的友元函数。getLength虽然不是Box的成员，但由于被声明为友元，可以直接访问length。
1.2 友元函数访问多个对象的私有成员
友元函数常用于操作两个或多个对象的私有成员。
代码实例：比较两个对象
#include <iostream>
using namespace std;class Box {
private:double length;
public:Box(double l) : length(l) {}// 声明友元函数friend bool compare(const Box& b1, const Box& b2);
};// 友元函数定义
bool compare(const Box& b1, const Box& b2) {return b1.length > b2.length; // 可以访问 b1 和 b2 的私有成员
}int main() {Box box1(10.5), box2(15.0);if (compare(box1, box2)) {cout << "Box1 is larger" << endl;} else {cout << "Box2 is larger" << endl;}return 0;
}
输出：
Box2 is larger
二、友元类
友元类允许一个类的所有成员函数访问另一个类的私有和保护成员。
友元类的特点：
- 友元类声明后，该类的所有成员函数都能访问另一个类的私有和保护成员。
- 友元关系是单向的，声明友元的类允许被访问，但反之不成立。
2.1 友元类的简单实例
代码实例：一个类操作另一个类
#include <iostream>
using namespace std;class Box; // 前向声明class Calculator {
public:double calculateVolume(const Box& b); // 计算体积
};class Box {
private:double length, width, height;
public:Box(double l, double w, double h) : length(l), width(w), height(h) {}// 声明友元类friend class Calculator;
};// 友元类成员函数的定义
double Calculator::calculateVolume(const Box& b) {return b.length * b.width * b.height; // 访问 Box 的私有成员
}int main() {Box box(3.0, 4.0, 5.0);Calculator calc;cout << "Volume of the box: " << calc.calculateVolume(box) << endl;return 0;
}
输出：
Volume of the box: 60
解释：
Calculator是Box的友元类。Calculator的成员函数calculateVolume可以直接访问Box的私有成员。
2.2 友元类的双向访问
如果两个类需要相互访问对方的私有成员，则需要在每个类中分别声明友元。
代码实例：双向友元
#include <iostream>
using namespace std;class B; // 前向声明class A {
private:int valueA;
public:A(int val) : valueA(val) {}// 声明 B 的成员函数为友元friend void display(const A& a, const B& b);
};class B {
private:int valueB;
public:B(int val) : valueB(val) {}// 声明 A 的成员函数为友元friend void display(const A& a, const B& b);
};// 友元函数定义
void display(const A& a, const B& b) {cout << "A: " << a.valueA << ", B: " << b.valueB << endl;
}int main() {A objA(10);B objB(20);display(objA, objB);return 0;
}
输出：
A: 10, B: 20
解释：
A的私有成员valueA和B的私有成员valueB都可以在display函数中访问。- 这需要双向声明友元关系。
三、友元模板
友元模板允许模板类或模板函数访问其他类的私有成员。
3.1 模板函数作为友元
代码实例：模板函数访问私有成员
#include <iostream>
using namespace std;class Box {
private:double length;
public:Box(double l) : length(l) {}// 声明模板函数为友元template <typename T>friend void displayLength(const T& obj);
};template <typename T>
void displayLength(const T& obj) {cout << "Length: " << obj.length << endl;
}int main() {Box box(10.5);displayLength(box);return 0;
}
输出：
Length: 10.5
3.2 模板类作为友元
代码实例：模板类访问私有成员
#include <iostream>
using namespace std;template <typename T>
class Calculator;class Box {
private:double length;
public:Box(double l) : length(l) {}// 声明模板类为友元template <typename T>friend class Calculator;
};template <typename T>
class Calculator {
public:void printLength(const Box& b) {cout << "Length: " << b.length << endl; // 访问私有成员}
};int main() {Box box(10.5);Calculator<int> calc;calc.printLength(box);return 0;
}
输出：
Length: 10.5
总结
友元的使用场景：
- 当需要跨类访问私有成员时（如运算符重载、对象比较）。
- 当需要将工具类设计为另一个类的友元（如计算器类访问目标类）。
- 需要实现灵活的模板操作。
优缺点：
- 优点：
- 提供了跨类访问的便利性。
- 实现复杂逻辑时，避免冗长的 getter/setter。
- 缺点：
- 破坏了封装性，可能导致类的耦合性提高。
友元是功能强大的工具，但应谨慎使用，以保持代码的可维护性。