operator <=> (spaceship operator)

1. C++20 前如何定义比较运算符

C++20 之前,必须为一个类型定义六个操作符,以提供对象所有比较的支持。
例如,若要比较Value 类型的对象(具有整型ID),则须实现以下操作:

class Value
{
private:
    long id;
    ...
    public:
    ...
   // equality operators:
    bool operator== (const Value& rhs) const {
        return id == rhs.id; // basic check for equality
    }
    bool operator!= (const Value& rhs) const {
        return !(*this == rhs); // derived check
    }
    // relational operators:
    bool operator< (const Value& rhs) const {
        return id < rhs.id; // basic check for ordering
    }
    bool operator<= (const Value& rhs) const {
        return !(rhs < *this); // derived check
    }
    bool operator> (const Value& rhs) const {
        return rhs < *this; // derived check
    }
    bool operator>= (const Value& rhs) const {
        return !(*this < rhs); // derived check
    }
};

     尽管大多数操作符都是根据其他操作符定义的(都基于operator == 或operator <),但
这些定义很繁琐,而且会增加很多阅读上的混乱。
此外,对于实现良好的类型,可能需要更多的声明:
• 若操作符不能抛出,就用noexcept 声明
• 若操作符可以在编译时使用,则使用constexpr 声明
• 若构造函数不是显式的,则将操作符声明为“隐藏友元”(在类结构中与友元一起声明,以便
两个操作数都成为参数,并支持隐式类型转换)
• 声明带有[[nodiscard]] 的操作符,以便在返回值未使用时强制发出警告。

class Value {
private:
    long id;
    ...
    public:
    constexpr Value(long i) noexcept // supports implicit type conversion
        : id{i} {
    }
    ...
	// equality operators:
	[[nodiscard]] friend constexpr
	bool operator== (const Value& lhs, const Value& rhs) noexcept {
		return lhs.id == rhs.id; // basic check for equality
	}
	[[nodiscard]] friend constexpr
	bool operator!= (const Value& lhs, const Value& rhs) noexcept {
		return !(lhs == rhs); // derived check for inequality
	}
	// relational operators:
	[[nodiscard]] friend constexpr
	bool operator< (const Value& lhs, const Value& rhs) noexcept {
		return lhs.id < rhs.id; // basic check for ordering
	}
	[[nodiscard]] friend constexpr
	bool operator<= (const Value& lhs, const Value& rhs) noexcept {
		return !(rhs < lhs); // derived check
	}
	[[nodiscard]] friend constexpr
	bool operator> (const Value& lhs, const Value& rhs) noexcept {
		return rhs < lhs; // derived check
	}
	[[nodiscard]] friend constexpr
	bool operator>= (const Value& lhs, const Value& rhs) noexcept {
		return !(lhs < rhs); // derived check
	}
};

2.C++20 后如何定义比较运算符

== 与!= 操作符
为了检查是否相等,现在定义== 操作符就够了。
当编译器找不到表达式的匹配声明a!=b 时,编译器会重写表达式并查找!(a==b)。若这不起作
用,编译器也会尝试改变操作数的顺序,所以也会尝试!(b==a):

a != b // tries: a!=b, !(a==b), and !(b==a)

因此,对于TypeA 的a 和TypeB 的b,编译器将能够识别并编译

a != b

若需要的话,可以这样做
• 一个独立函数operator!=(TypeA, TypeB)
• 一个独立函数operator==(TypeA, TypeB)
• 一个独立函数operator==(TypeB, TypeA)
• 一个成员函数TypeA::operator!=(TypeB)
• 一个成员函数TypeA::operator==(TypeB)
• 一个成员函数TypeB::operator==(TypeA)

直接调用已定义的operator!= 是首选(但类型的顺序必须合适),更改操作数的顺序为最低的优
先级。同时拥有独立函数和成员函数会出现歧义错误。因此,

bool operator==(const TypeA&, const TypeB&);

或:

class TypeA {
public:
...
bool operator==(const TypeB&) const;
};

编译器可以进行编译:

MyType a;
MyType b;
...
a == b; // OK: fits perfectly
b == a; // OK, rewritten as: a == b
a != b; // OK, rewritten as: !(a == b)
b != a; // OK, rewritten as: !(a == b)

当重写将操作数转换为已定义成员函数的参数时,也可以对第一个操作数进行隐式类型转换。

<=> 操作符
对于所有的关系操作符,没有等价的规则说定义小于操作符就足够了。但现在,只需要定义新
的操作符<=> 即可。
事实上,以下内容足以让开发者使用所有可能的比较操作符:

#include <compare>
class Value {
private:
    long id;
    ...
public:
    constexpr Value(long i) noexcept
    : id{i} {
    }
    ...
    // enable use of all equality and relational operators:
    auto operator<=> (const Value& rhs) const = default;
};

通常,== 可以通过定义== 和!= 操作符来处理对象的相等性,而<=> 操作符通过定义关系操作
符来处理对象的顺序。若通过=default 声明操作符<=>,则可以使用了一个特殊的规则,即默认成
员操作符<=>:

class Value {
...
auto operator<=> (const Value& rhs) const = default;
};

生成对应的成员== 操作符,从而得到:

class Value {
...
auto operator<=> (const Value& rhs) const = default;
auto operator== (const Value& rhs) const = default; // implicitly generated
};

结果是两个操作符都使用了默认实现,逐个成员对象进行比较,所以类中成员的顺序很重要。
因此,

class Value {
...
auto operator<=> (const Value& rhs) const = default;
};

至此,我们得到了能够使用所有六个比较操作符所需的一切。
此外,即使将操作符声明为成员函数,也适用于生成的操作符:
• 若比较成员不抛出异常,则是noexcept
• 若可在编译时比较成员,则是constexpr
• 因为重写,还可以支持第一个操作数的隐式类型转换
通常情况下,== 和<=> 操作符处理不同但相关的事情:
• == 操作符定义相等性,可由相等操作符== 和!= 使用。
• <=> 操作符定义了排序,可以由关系操作符<、<=、> 和>= 使用。
注意,当默认或使用<=> 操作符时,必须包含头文件<compare>。

<=> 操作符的实现

为了更好地控制生成的比较操作符,可以自己定义== 和<=> 操作符。例如:

#include <compare>
class Value {
private:
    long id;
    ...
public:
    constexpr Value(long i) noexcept
    : id{i} {
    }
    ...
    // for equality operators:
    bool operator== (const Value& rhs) const {
        return id == rhs.id; // defines equality (== and !=)
    }
    // for relational operators:
    auto operator<=> (const Value& rhs) const {
        return id <=> rhs.id; // defines ordering (<, <=, >, and >=)
    }
};

可以指定哪个成员以哪个顺序重要或实现特殊行为。
这些基本操作符的工作方式是,若表达式使用其中一个比较操作符,并且没有找到匹配的直接
定义,则重写表达式,以便使用这些操作符。
与重写相等操作符调用相对应,重写也可能改变关系操作数的顺序,从而可能对第一个操作数
启用隐式类型转换。例如:

x <= y

没有找到<= 操作符的匹配定义,可以重写为

(x <=> y) <= 0

甚至

<= (y <=> x)

通过重写,<=> 操作符执行一个三向比较,生成一个可以与0 比较的值:
• 若x<=>y 的值等于0,则x 和y 等于或相等。
• 若x<=>y 小于0,则x 小于y.
• 若x<=>y 大于0,则x 大于y。
但请注意,<=> 操作符的返回类型不是整数值。返回类型是表示比较类别的类型,可以是强排
序、弱排序或偏排序,但这些类型支持与0 进行比较。

  • 20
    点赞
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值