类内与类外运算符过载

Operator overloading inside vs outside class

本文关键字：运算符      更新时间：2023-10-16

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

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

与

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

首先使用您的类(重新格式化为我喜欢的样式)来考虑这个例子：

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.
}
相关文章：