内部操作符与外部类重载

这个问题在这里已经有了答案：

运算符在类外部重载[重复] 3个答案

运算符重载的基本规则和习惯用法是什么？ 7个答案

---

首先考虑使用你的类的这个例子（重新格式化我喜欢的风格）：

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

链接地址: http://www.djcxy.com/p/12715.html

上一篇: Operator overloading inside vs outside class

下一篇: operator overloading in c++