Question

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

getNumber()

VS

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

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

运算符重载内部vs外部类

1 个答案: