7 运算符

约 2777 字大约 9 分钟

2025-06-22

引入

传统的 6 种双路比较运算符（== , !=, <, >, <=, >=）返回一个 bool 值，其结果或为 true 或为 false。这造成了一些问题：

至少需要 2 次比较才能确定结果是小于、大于和等于中的哪一种，这在比较的性能开销较大时会造成不必要的性能消耗；
为自定义类型定义比较运算时，需要定义 6 次，而这其中大部分是重复工作。

为了以统一的方式解决第一个问题，C++20 引入了三路比较运算符 <=>又称宇宙飞船运算符 (Spaceship Operator)

三路比较运算符的优先级低于移位运算符 <<、>>，高于其他比较运算符。三路比较的支持定义于库 < compare> 中。对于表达式 a <=> b，三路比较运算符返回一个比较对象，指示比较的结果。

三向比较的返回结果并不是一个普通类型它只能与0和自身类型比较，是这3个类只实现了参数类型为自身类型和`nullptr_t的比较运算符函数。

bool b = 7 <=> 11 < 0; // b == true

三向比较的返回类型

1、std::strong_ordering强序关系

不存在不可比较的对象，相等蕴涵可替换性。大部分基础类型与标准库类型的三路比较都返回这种结果。

有3种比较结果 1. stdless 表示< 2. stdequal 表示== 3. stdgreater 表示>

std::strong_ordering类型的结果强调的是strong的含义，表达的是一种可替换性，简单来说，若x == y，那么在任何情况下rhs和lhs都可以相互替换，也就是 f(x) == f(y)。

对于基本的int类型，三向比较返回的是std::strong_ordering

cout << typeid(7 <=> 11).name()<<endl;

对于有复杂结构的类型stdstrong_ordering。

struct B {  
    int a;  
    long b;  
    auto operator<=>(const B &) const = default;  
};  
  
struct D : B {  
    short c;  
    auto operator<=>(const D &) const = default;  
};  
  
int main() {  
    D x1, x2;  
    cout << typeid(x1 <=> x2).name();  //std::strong_ordering
    return 0;  
}

默认情况下自定义类型是不存在三向比较运算符函数的，需要用户显式默认声明比如在结构体B和D中声明auto operator <=> (const B&) const = default;和auto operator <=> (const D&) const = default;。对结构体B而言，由于int和long的比较结果都是stdstrong_ordering。同理，对于结构体D，其基类和成员的比较结果是 stdstrong_ordering。另外，明确运算符的返回类型，可以使用std::strong_ ordering替换auto。

2、std::weak_ordering弱序关系

不存在不可比较的对象，但相等仍不蕴涵可替换性。基础类型与标准库类型的三路比较不会返回这种结果。

也有3种比较结果， 1. stdless、 2. stdequivalent 3. stdgreater

若有x == y，则f(x) != f(y)。这种情况在基础类型中并没有，但是它常常发生在用户自定义类中，比如一个大小写不敏感的字符串类

int ci_compare(const char *s1, const char *s2) {  
    while (tolower(*s1) == tolower(*s2++)) {  
        if (*s1++ == '\0') {  
            return 0;  
        }  
    }  
    return tolower(*s1) - tolower(*--s2);  
}  
  
class CIString {  
private:  
    string str_;  
public:  
    CIString(const char *s) : str_(s) {}  
    weak_ordering operator<=>(const CIString &b) const {  
        return ci_compare(str_.c_str(), b.str_.c_str()) <=> 0;  
    }  
};  
  
int main(){  
    CIString s1{"HELLO"}, s2{"hello"};  
    cout << (s1 <=> s2 == 0); // 输出为true  
}

对于s1和s2的比较结果是 stdequivalent，表示两个操作数是等价的，但是它们不是相等的也不能相互替换。当stdstrong_ ordering同时出现在基类和数据成员的类型中时，该类型的三向比较结果是std::weak_ordering，不能显式声明默认三向比较运算符函数

3、partial_ordering偏序关系

存在不可比较的对象。对于可比较的对象，结果的“相等”实际上是“等价” (equivalent) 而非真正的 “相等” (equal)。这里的“相等”指既等价又可互相替换，也就是说若 a = b，则对于任意函数 f 有 f(a) = f(b)。而 partial_ordering 的“相等”不保证可替换性。在基础类型以及标准库类型中，只有浮点数参与比较时，结果才可能是 partial_ordering，因为 NaN 与任何值都不可比较。除此之外也存在等价但不相等的值，如 +0.0 == -0.0，但它们对于取符号函数的结果不同（< cmath> 中的 signbit() 函数）。

有4种比较结果 1. stdless 2. stdequivalent 3. stdgreater 4. stdunordered

std:: partial_ordering约束力比stdpartial_ ordering::unordered，表示进行比较的两个操作数没有关系。比如基础类型中的浮点数

cout << typeid(7.7 <=> 11.1).name();
cout << typeid(7.7 <=> 7.7).name();

会输出class std::partial_ordering因为浮点的集合中存在一个特殊的NaN，它和其他浮点数值没关系

cout<<0.0/0.0<<endl;//nan  
cout << ((0.0 / 0.0 <=> 1.0) == partial_ordering::unordered)<<endl;//true

当std partial_ordering同时出现在基类和数据成员的类型中时，该类型的三向比较结果是stdcommon_comparison_category，它可以帮助我们在一个类型合集中判断出最终三向比较的结果类型，当类型合集中存在不支持三向比较的类型时，该模板元函数返回void。

对基础类型的支持

对两个算术类型的操作数进行一般算术转换，然后进行比较。其中整型的比较结果为 stdpartial_ordering。例如7 <=> 11.1中，整型7会转换为浮点类型，然后再进行比较，最终结果为std::partial_ordering类型。
对于无作用域枚举类型和整型操作数，枚举类型会转换为整型再进行比较，无作用域枚举类型无法与浮点类型比较

enum color {
	red
};
auto r = red <=> 11; //编译成功 
auto r = red <=> 11.1; //编译失败

对两个相同枚举类型的操作数比较结果，如果枚举类型不同，则无法编译。
对于其中一个操作数为bool类型的情况，另一个操作数必须也是bool类型，否则无法编译。比较结果为std::strong_ordering。
不支持作比较的两个操作数为数组的情况，会导致编译出错

int arr1[5];  
int arr2[5];  
auto r = arr1 <=> arr2; // 编译失败

对于其中一个操作数为指针类型的情况，需要另一个操作数是同样类型的指针，或者是可以转换为相同类型的指针，比如数组到指针的转换、派生类指针到基类指针的转换等，最终比较结果为std::strong_ordering

char arr1[5];  
char arr2[5];  
char* ptr = arr2;  
auto r = ptr <=> arr1;

可以编译成功，若将代码中的arr1改写为int arr1[5]，则无法编译，因为int [5] 无法转换为char * 。如果将char * ptr = arr2;修改为void * ptr = arr2;，代码就可以编译成功了。

自动生成的比较运算符函数

标准库utility中提供了一个名为std::rel_ops的命名空间，在用户自定义类型已经提供了== 运算符函数和<运算符函数的情况下，帮助用户实现其他4种运算符函数，包括!=、>、<=和>=

using namespace std::rel_ops;  
  
int ci_compare(const char *s1, const char *s2) {  
    while (tolower(*s1) == tolower(*s2++)) {  
        if (*s1++ == '\0') {  
            return 0;  
        }  
    }  
    return tolower(*s1) - tolower(*--s2);  
}  
  
class CIString2 {  
private:  
    string str_;  
public:  
    CIString2(const char* s) : str_(s) {}  
    bool operator < (const CIString2& b) const {  
        return ci_compare(str_.c_str(), b.str_.c_str()) < 0;  
    }  
};  
  
int main(){  
    CIString2 s1{ "hello" }, s2{ "world" };  
    bool r = s1 >= s2;  
}

因为C++20标准有了三向比较运算符的关系，所以不推荐上面这种做法了。C++20标准规定，如果用户为自定义类型声明了三向比较运算符，那么编译器会为其自动生成<、>、<=和>= 这4种运算符函数。对于CIString我们可以直接使用这4种运算符函数

CIString s1{ "hello" }, s2{ "world" }; 
bool r = s1 >= s2;

三向比较运算符能表达两个操作数是相等或者等价的含义，为什么标准只允许自动生成4种运算符函数，却不能自动生成== 和!=这两个运算符函数呢？实际上这里存在一个严重的性能问题。在C++20标准拟定三向比较的早期，是允许通过三向比较自动生成6个比较运算符函数的，而三向比较的结果类型也不是3种而是5种，多出来的两种分别是 stdweak_equality。但是在提案文档p1190中提出了一个严重的性能问题。简单来说，假设有一个结构体：

struct S {  
    vector<string> names;  
    auto operator<=>(const S &) const = default;  
};

它的三向比较运算符的默认实现这样的：

template<typename T>  
strong_ordering operator<=>(const vector<T>& lhs, const vector<T> & rhs){  
    size_t min_size = min(lhs.size(), rhs.size());  
    for (size_t i = 0; i != min_size; ++i) {  
        if (auto const cmp = std::compare_3way(lhs[i], rhs[i]); cmp != 0) {  
            return cmp;  
        }  
    }  
    return lhs.size() <=> rhs.size();  
}

这个实现对于<和>这样的运算符函数没有问题，因为需要比较容器中的每个元素。但是== 运算符就显得十分低效，对于== 运算符高效的做法是先比较容器中的元素数量是否相等，如果元素数量不同，则直接返回false

template<typename T>  
bool operator==(const vector<T>& lhs, const vector<T>& rhs){  
    const size_t size = lhs.size();  
    if (size != rhs.size()) {  
        return false;  
    }  
    for (size_t i = 0; i != size; ++i) {  
        if (lhs[i] != rhs[i]) {  
            return false;  
        }  
    }  
    return true;  
}

如果标准允许用三向比较的算法自动生成== 运算符函数会发生什么事情，很多旧代码升级编译环境后会发现运行效率下降了，尤其是在容器中元素数量众多且每个元素数据量庞大的情况下。很少有程序员会注意到三向比较算法的细节，导致这个性能问题难以排查。基于这种考虑，C++委员会修改了原来的三向比较提案，规定声明三向比较运算符函数只能够自动生成4 种比较运算符函数。由于不需要负责判断是否相等，因此stdweak_ equality也退出了历史舞台。对于== 和!=两种比较运算符函数，只需要多声明一个== 运算符函数!=运算符函数会根据前者自动生成

class CIString {  
public:  
    CIString(const char* s) : str_(s) {}  
    weak_ordering operator<=>(const CIString& b) const {  
        return ci_compare(str_.c_str(), b.str_.c_str()) <=> 0;  
    }  
    bool operator == (const CIString& b) const {  
        return ci_compare(str_.c_str(), b.str_.c_str()) == 0;  
    }  
private:  
    string str_;  
};  
CIString s1{ "hello" }, s2{ "world" };  
bool r1 = s1 >= s2; // 调用operator<=>  
bool r2 = s1 == s2; // 调用operator ==

贡献者

pinkdopeybug

版权所有

版权归属：PinkDopeyBug

许可证：署名 4.0 国际 (CC-BY-4.0)

7 运算符

公告