如何将C++的运算符重载限制在类作用域内？

问题 #

我有一个类A，经常需要对std::pair执行逐元素加法操作。为了方便，我想为两个std::pair重载operator+，代码如下：

template <typename T, typename U>
std::pair<T, U> operator+(std::pair<T, U> left, std::pair<T, U> right)
{
    return {left.first + right.first, left.second + right.second};
}

但我不希望在A的作用域之外引入这个重载，因为它仅在A内部有用。于是我尝试将其定义为A的成员函数：

class A
{
    // ...
    template <typename T, typename U>
    std::pair<T, U> operator+(std::pair<T, U> left, std::pair<T, U> right)
    {
        return {left.first + right.first, left.second + right.second};
    }
    // ...
};

但这样无法编译，因为C++会将其视为类A的成员运算符重载，而成员operator+只能接受一个参数。请问正确的实现方式是什么？

可行的实现方式 #

方式一：将operator+定义为类A的友元模板函数 #

把重载的operator+声明为类A的友元，它本质是全局函数，但仅能通过ADL（参数依赖查找）在类A的作用域内被找到，不会污染全局作用域。代码示例：

class A
{
    // ...
    template <typename T, typename U>
    friend std::pair<T, U> operator+(std::pair<T, U> left, std::pair<T, U> right)
    {
        return {left.first + right.first, left.second + right.second};
    }
    // ...
};

外部代码无法直接调用这个重载，满足“仅在A内部有用”的需求。

方式二：定义静态模板替代函数 #

如果不想重载运算符，可以在类A内部定义静态模板函数来实现逐元素加法，完全限制在类作用域内：

class A
{
    // ...
    template <typename T, typename U>
    static std::pair<T, U> add_pair(const std::pair<T, U>& left, const std::pair<T, U>& right)
    {
        return {left.first + right.first, left.second + right.second};
    }
    // ...

    // 内部使用示例
    void some_method()
    {
        std::pair<int, double> p1 = {1, 2.5};
        std::pair<int, double> p2 = {3, 4.5};
        auto p3 = add_pair(p1, p2);
    }
};

方式三：在成员函数内定义lambda（C++11及以上） #

如果仅在某个特定成员函数内需要该逻辑，可以在函数内部定义lambda，作用域最小：

class A
{
    // ...
    void some_method()
    {
        auto add_pair = [](const auto& left, const auto& right) {
            return std::pair{left.first + right.first, left.second + right.second};
        };

        std::pair<int, double> p1 = {1, 2.5};
        std::pair<int, double> p2 = {3, 4.5};
        auto p3 = add_pair(p1, p2);
    }
    // ...
};

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