友元operator==出现「原子约束满足依赖自身」错误的原因与解决

当你将operator==改为友元函数时，编译器报错的核心原因是ADL（参数依赖查找）触发了循环约束检查：

1. 类内部声明的模板友元operator==会被注入到Box<T>所在的命名空间中。
2. 检查友元函数的requires约束（比如T == U）时，编译器会对t == u执行重载解析，此时ADL会将Box<T>的所在命名空间纳入查找范围。
3. 尽管T和U本身不是Box类型，但ADL会找到同命名空间中声明的友元operator==(Box<T>, U)和operator==(U, Box<T>)。编译器需要判断这些友元函数是否参与t == u的重载解析，而判断的前提是它们的约束是否满足——但这些约束又回到了T == U的检查，形成循环依赖，最终触发“satisfaction of atomic constraint depends on itself”错误。

而成员函数版本不会出现这个问题：成员operator==仅当左操作数是Box<T>时才会被调用，t == u的左操作数是T，因此不会触发成员函数的查找，自然不会形成循环。

方案1：提前声明友元模板，分离声明与定义 #

将友元函数的模板声明放在类外部，类内部仅声明友元实例，避免ADL在约束检查时递归查找类内的友元声明：

#include <concepts>

// 提前声明Box类
template<typename T>
struct Box;

// 提前声明友元运算符模板
template<typename T, typename U>
    requires std::equality_comparable_with<T, U>
bool operator==(const Box<T>&, const U&);

template<typename T, typename U>
    requires std::equality_comparable_with<U, T>
bool operator==(const U&, const Box<T>&);

template<typename T>
struct Box {
    T value;

    // 声明特定实例为友元
    friend bool operator==<>(const Box<T>&, const U&) requires std::equality_comparable_with<T, U>;
    friend bool operator==<>(const U&, const Box<T>&) requires std::equality_comparable_with<U, T>;
};

// 定义友元运算符
template<typename T, typename U>
    requires std::equality_comparable_with<T, U>
bool operator==(const Box<T>& x, const U& y) {
    return x.value == y;
}

template<typename T, typename U>
    requires std::equality_comparable_with<U, T>
bool operator==(const U& x, const Box<T>& y) {
    return x == y.value;
}

方案2：在requires子句中限定比较的查找范围 #

在约束的requires表达式中，通过using std::operator==;优先使用标准库中的比较运算符，避免ADL查找当前命名空间的友元函数，打破循环：

#include <concepts>

template<typename T>
struct Box {
    T value;

    template<typename U>
    friend bool operator==(const Box<T>& x, const U& y) 
        requires requires(T t, U u) { 
            using std::operator==; // 限定优先使用std中的比较操作
            t == u; 
        } {
        return x.value == y;
    }

    template<typename U>
    friend bool operator==(const U& x, const Box<T>& y) 
        requires requires(U u, T t) { 
            using std::operator==;
            u == t; 
        } {
        return x == y.value;
    }
};

方案3：简化约束，直接使用值比较的表达式 #

如果不需要严格依赖std::equality_comparable_with，可以直接在requires子句中使用x.value == y的形式（注意：此方式仅适用于单向比较，双向比较仍需补充反向运算符）：

template<typename T>
struct Box {
    T value;

    template<typename U>
    friend bool operator==(const Box<T>& x, const U& y) 
        requires requires { x.value == y; } {
        return x.value == y;
    }

    template<typename U>
    friend bool operator==(const U& x, const Box<T>& y) 
        requires requires { x == y.value; } {
        return x == y.value;
    }
};

内容的提问来源于stack exchange，提问作者Da Spud Lord