如何在C++中合理规避友元方法引发的循环依赖问题？

问题背景 #

我定义了两个类 MyString 和 LongNumber，要求 LongNumber 的 Foo 方法成为 MyString 的友元，以此访问 MyString 的私有成员。尝试用前向声明规避循环依赖后，编译报错：

...MyString.h(11,26): error C2027: use of undefined type 'LongNumber'

错误指向 friend void LongNumber::Foo(MyString& str); 这一行。调整头文件包含顺序、修改前向声明都无效，担心直接包含头文件会引发循环依赖，询问该需求是否可实现。

错误原因 #

• 仅前向声明 class LongNumber; 只能告诉编译器“存在这个类”，但无法提供类的内部细节（比如 Foo 方法的存在）。当在 MyString 中声明 LongNumber::Foo 为友元时，编译器需要确认该方法确实存在，因此仅前向声明不足以满足要求。
• 同时 LongNumber 类中直接持有 MyString digits; 成员变量，这要求编译器必须知道 MyString 的完整定义，不能仅靠前向声明。

可行解决方案 #

方案1：提前声明LongNumber的Foo方法 #

在 MyString.h 中，先声明 LongNumber 类及其 Foo 方法的框架，让编译器识别该方法的存在，再定义 MyString 类并声明友元：

// File: MyString.h
#pragma once

// 提前声明LongNumber类和Foo方法，让编译器知晓该方法存在
class MyString;
class LongNumber {
public:
    void Foo(MyString& str);
};

class MyString
{
    char* symbols;
    size_t capacity;
    size_t length;

    friend void LongNumber::Foo(MyString& str); // 此时编译器能识别该方法

    // 公共方法示例
public:
    MyString() : symbols(nullptr), capacity(0), length(0) {}
    // 其他构造、析构等方法
};

修改 LongNumber.h，直接包含 MyString.h（因为需要 MyString 的完整定义来声明成员变量）：

// File: LongNumber.h
#pragma once
#include "MyString.h" // 必须包含，否则无法定义MyString类型的成员变量

class LongNumber
{
    uint8_t sign;
    MyString digits;
    void Foo(MyString& str); // 与MyString.h中的声明保持一致

    // 公共方法示例
public:
    LongNumber() : sign(0) {}
};

这种方式既精准控制了友元范围（仅Foo方法有权限），又避免了循环依赖问题。

方案2：声明整个LongNumber类为MyString的友元 #

如果不需要严格限制访问权限，允许LongNumber的所有成员方法访问MyString的私有成员，这种方法更简单：

修改 MyString.h，仅前向声明LongNumber并声明整个类为友元：

// File: MyString.h
#pragma once

class LongNumber; // 仅前向声明即可

class MyString
{
    char* symbols;
    size_t capacity;
    size_t length;

    friend class LongNumber; // 声明整个类为友元

    // 公共方法示例
public:
    MyString() : symbols(nullptr), capacity(0), length(0) {}
};

LongNumber.h 保持原逻辑（包含MyString.h）即可。这种方式代码更简洁，但会放开LongNumber所有成员对MyString私有成员的访问权限。

方案对比 #

• 方案1：权限控制精准，适合对访问权限有严格要求的场景。
• 方案2：实现简单，适合权限控制要求不高的场景。

完整代码示例（方案1） #

MyString.h

#pragma once

class MyString;
class LongNumber {
public:
    void Foo(MyString& str);
};

class MyString
{
    char* symbols;
    size_t capacity;
    size_t length;

    friend void LongNumber::Foo(MyString& str);

public:
    MyString() : symbols(nullptrptr), capacity(0), length(0) {}
    ~MyString() { delete[] symbols; }
};

LongNumber.h

#pragma once
#include "MyString.h"

class LongNumber
{
    uint8_t sign;
    MyString digits;
    void Foo(MyString& str);

public:
    LongNumber() : sign(0) {}
};

LongNumber.cpp

#include "LongNumber.h"

void LongNumber::Foo(MyString& str)
{
    // 可以直接访问MyString的私有成员，例如：
    // str.length = 5;
}

Main.cpp

#include <iostream>
#include "MyString.h"
#include "LongNumber.h"

int main() {
    MyString s;
    LongNumber num;
    num.Foo(s);
    return 0;
}

内容的提问来源于stack exchange，提问作者Firegreat