编辑“︁C++ 友元类”︁

= C++友元类 =

'''友元类（Friend Class）'''是C++面向对象编程中的一个重要特性，它允许一个类访问另一个类的私有（private）和保护（protected）成员。这种机制打破了类的封装性，但在某些特定场景下非常有用，比如需要紧密协作的两个类之间共享数据时。

== 基本概念 ==

在C++中，类的私有成员通常只能被该类的成员函数访问。然而，通过使用'''friend'''关键字，可以授权其他类或函数访问这些私有成员。当一个类被声明为另一个类的友元时，它可以访问后者所有的私有和保护成员。

友元关系是单向的，不具有传递性。例如，如果类A是类B的友元，类B并不会自动成为类A的友元。此外，友元关系也不能继承。

=== 语法 ===
友元类的声明方式如下：
<syntaxhighlight lang="cpp">
class ClassName {
    friend class FriendClass; // 声明FriendClass为友元类
private:
    // 私有成员
};
</syntaxhighlight>

== 代码示例 ==

以下是一个简单的示例，展示如何使用友元类：

<syntaxhighlight lang="cpp">
#include <iostream>
using namespace std;

class SecretHolder {
private:
    int secretValue;

public:
    SecretHolder(int val) : secretValue(val) {}

    // 声明FriendClass为友元类
    friend class FriendClass;
};

class FriendClass {
public:
    void displaySecret(SecretHolder& obj) {
        // 可以访问SecretHolder的私有成员
        cout << "The secret value is: " << obj.secretValue << endl;
    }
};

int main() {
    SecretHolder sh(42);
    FriendClass fc;
    fc.displaySecret(sh); // 输出: The secret value is: 42
    return 0;
}
</syntaxhighlight>

'''输出:'''
<pre>
The secret value is: 42
</pre>

在这个例子中，`FriendClass`被声明为`SecretHolder`的友元类，因此它可以访问`SecretHolder`的私有成员`secretValue`。

== 实际应用场景 ==

友元类在以下场景中特别有用：

1. '''紧密协作的类'''：当两个类需要紧密协作，频繁访问彼此的私有成员时（如容器类和迭代器类）。
2. '''单元测试'''：测试类可能需要访问被测试类的私有成员以验证其正确性。
3. '''设计模式实现'''：某些设计模式（如工厂模式）可能需要友元关系。

=== 迭代器模式示例 ===
以下是一个使用友元类实现简单迭代器的例子：

<syntaxhighlight lang="cpp">
#include <iostream>
using namespace std;

class IntContainer {
private:
    int data[10];
    int size;

public:
    IntContainer() : size(0) {}

    void add(int value) {
        if (size < 10) {
            data[size++] = value;
        }
    }

    // 声明迭代器为友元类
    friend class Iterator;
};

class Iterator {
private:
    IntContainer& container;
    int index;

public:
    Iterator(IntContainer& c) : container(c), index(0) {}

    bool hasNext() {
        return index < container.size;
    }

    int next() {
        return container.data[index++];
    }
};

int main() {
    IntContainer container;
    container.add(1);
    container.add(2);
    container.add(3);

    Iterator it(container);
    while (it.hasNext()) {
        cout << it.next() << " ";
    }
    // 输出: 1 2 3
    return 0;
}
</syntaxhighlight>

'''输出:'''
<pre>
1 2 3
</pre>

== 注意事项 ==

使用友元类时需要注意以下几点：

1. '''破坏封装'''：友元关系会破坏类的封装性，应谨慎使用。
2. '''单向性'''：友元关系是单向的，不具有对称性。
3. '''不可传递'''：如果A是B的友元，B是C的友元，A并不会自动成为C的友元。
4. '''不可继承'''：友元关系不会被子类继承。

== 友元类与设计 ==

友元类在类设计中是一种强大的工具，但应该谨慎使用。过度使用友元关系可能导致代码难以维护和理解。在设计时，应考虑是否有其他替代方案（如公有接口）可以达到相同目的。

=== 替代方案 ===
在某些情况下，可以使用以下方式替代友元类：
* 提供公有访问方法
* 使用嵌套类
* 重构设计，减少类间的紧密耦合

== 总结 ==

友元类是C++中一种特殊的类关系，它允许一个类访问另一个类的私有和保护成员。虽然这会破坏封装性，但在需要紧密协作的类之间共享数据时非常有用。使用时应当权衡利弊，确保不会过度破坏代码的封装性和可维护性。

<mermaid>
classDiagram
    class SecretHolder {
        -int secretValue
        +SecretHolder(int val)
        +friend FriendClass
    }
    
    class FriendClass {
        +displaySecret(SecretHolder& obj)
    }
    
    SecretHolder --> FriendClass : friend
</mermaid>

== 参见 ==
* [[C++友元函数]]
* [[C++类和对象]]
* [[C++封装性]]

[[Category:编程语言]]
[[Category:C++]]
[[Category:C++ 面向对象基础]]