C++中类的【友元】详解

C++中类的【友元】详解

引用

CSDN

1.

https://blog.csdn.net/chenai886/article/details/144667981

在C++中，友元是一种特殊的关系，允许某个函数或类访问另一个类的私有成员和保护成员。友元打破了类的封装性，但也为实现一些复杂逻辑提供了便利。

下面，我会用详细解释和大量代码实例帮助你通俗易懂地理解友元函数、友元类、友元模板的概念和实际用途。

一、友元函数

友元函数是一种非成员函数，但它可以直接访问一个类的私有和保护成员。它是通过
friend
关键字声明的。

友元函数的特点：

1. 友元函数不是类的成员，但可以访问类的私有和保护成员。
2. 友元函数需要在类中声明，定义可以在类外。
3. 友元关系是单向的，类给函数友元权限，但函数没有反向权限。

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

解释：

1. getLength
   是
   Box
   的友元函数。
2. 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

二、友元类

友元类允许一个类的所有成员函数访问另一个类的私有和保护成员。

友元类的特点：

1. 友元类声明后，该类的所有成员函数都能访问另一个类的私有和保护成员。
2. 友元关系是单向的，声明友元的类允许被访问，但反之不成立。

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

解释：

1. Calculator
   是
   Box
   的友元类。
2. 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

解释：

1. A
   的私有成员
   valueA
   和
   B
   的私有成员
   valueB
   都可以在
   display
   函数中访问。
2. 这需要双向声明友元关系。

三、友元模板

友元模板允许模板类或模板函数访问其他类的私有成员。

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

总结

友元的使用场景：

1. 当需要跨类访问私有成员时（如运算符重载、对象比较）。
2. 当需要将工具类设计为另一个类的友元（如计算器类访问目标类）。
3. 需要实现灵活的模板操作。

优缺点：

• 优点：

• 提供了跨类访问的便利性。

• 实现复杂逻辑时，避免冗长的 getter/setter。

• 缺点：

• 破坏了封装性，可能导致类的耦合性提高。

友元是功能强大的工具，但应谨慎使用，以保持代码的可维护性。