运算符重载内部与外部类

Question

内部类和外部类重载有什么区别？

class A{
    public:
       bool operator==(const A *i){
         ....
         ....
       }
 };

对比

 bool operator==(const A *i , const A *j){
   ....
   .... 
 }

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. 
}

这里

• 由于参数是指针，因此客户端代码必须 apply &。
• 由于方法不是，因此无法比较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.
}

… 然后

• 保证的定义不依赖于 class 的内部实现细节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.
}