c++ - 运算符在类内与类外重载

Question

<分区>

Answer 1

首先考虑使用您的类(重新格式化为我喜欢的样式)的示例:

class A
{
public:
    auto operator==( A const* p )
        -> bool
    {
        return true;        // Whatever.
    }
};

auto main()
    -> int
{
    A u{}, v{};
    A const c{};

    bool const r1 = (u == &v);  // OK but needlessly annoying.
    bool const r2 = (c == &v);  // !Will not compile. 
}

这里

• 由于参数是指针，客户端代码必须应用&。
• 由于该方法不是const，因此无法比较const 的对象。

因此，传统的做法是通过引用传递参数，并使方法const:

class B
{
public:
    auto operator==( B const& o ) const
        -> bool
    {
        return true;        // Whatever.
    }
};

auto main()
    -> int
{
    B u{}, v{};
    B const c{};

    bool const r1 = (u == v);   // OK.
    bool const r2 = (c == v);   // OK.
}

如果在类外定义比较，像这样:

class B
{};

auto operator==( B const& u, B const& v )
    -> bool
{
    return true;        // Whatever.
}

auto main()
    -> int
{
    B u{}, v{};
    B const c{};

    bool const r1 = (u == v);   // OK.
    bool const r2 = (c == v);   // OK.
}

……然后

• 保证的定义不依赖于 B 类的内部实现细节，可以想象这在未来可能会发生变化。
• 第一个参数也可以是隐式转换为 B 的值。
• 如果需要，您可以有不同类型的正式参数，其中类仅出现在第二个参数中，如下所示:

auto operator==( int const u, B const& v )
    -> bool
{
    return true;        // Whatever.
}

如果您选择通过 friend 机制(以便通过 ADL 查找找到它们)将这些非成员运算符内嵌在类定义中，那么您将失去第一个要点的优势，但是您随后在类定义中拥有与使用该类相关的所有代码:

class B
{
public:
    friend
    auto operator==( B const& u, B const& v )
        -> bool
    {
        return true;        // Whatever.
    }

    friend
    auto operator==( int const u, B const& v )
        -> bool
    {
        return true;        // Whatever.
    }
};

auto main()
    -> int
{
    B u{}, v{};
    B const c{};

    bool const r1 = (u == v);   // OK.
    bool const r2 = (c == v);   // OK.
    bool const r3 = (42 == v);  // OK.
}