当前位置：首页 > article >正文

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

article 2024/12/25 14:15:48

在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;
}