首先考虑使用您的类的示例(重新格式化为我喜欢的样式):
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.
}