C++20 三向比较操作符（）的编译器实现：优化默认比较与自定义类型的设计 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

C++20 三向比较操作符（<=>）：编译器实现、优化与自定义类型设计

各位好，今天我们来深入探讨C++20引入的三向比较操作符（<=>，也称为宇宙飞船操作符）。这个操作符极大地简化了比较操作的实现，尤其是在处理自定义类型时。我们将从编译器实现的角度入手，讨论如何优化默认比较，以及如何在自定义类型中巧妙地设计和利用<=>。

1. 三向比较操作符的基本原理

三向比较操作符<=>的设计目标是返回一个可以表示小于、等于或大于三种关系的类型。具体来说，它返回一个具有以下属性的类型：

可转换为布尔值： 可以隐式转换为bool，用于判断相等性。
支持与其他比较操作符的合成： 能够根据其结果合成其他比较操作符（<、>、<=、>=、==、!=）。

C++20标准库提供了三种主要的返回类型：

类型	含义	使用场景
`std::strong_ordering`	强排序。两个值相等当且仅当它们完全相同。例如，整数的比较。	需要区分完全相同的对象，并且相等关系具有意义。
`std::weak_ordering`	弱排序。两个值相等但并非完全相同。例如，浮点数的比较（NaN的处理）。	允许相等但并非完全相同的情况，并且相等关系具有意义。
`std::partial_ordering`	偏序。某些值无法进行比较。例如，浮点数的比较（NaN与任何值的比较）。	允许某些值无法比较的情况，例如涉及NaN的浮点数比较。

这三种类型都定义了预定义的常量，用于表示比较结果：

std::strong_ordering::less
std::strong_ordering::equal
std::strong_ordering::greater
std::strong_ordering::equivalent (仅weak_ordering和partial_ordering支持)
std::partial_ordering::unordered (仅partial_ordering支持)

2. 编译器如何实现三向比较

编译器在处理<=>时，需要进行以下几个步骤：

查找<=>运算符： 首先，编译器会查找类中是否定义了<=>运算符的重载版本。如果找到了，就直接使用该重载版本。
默认比较合成： 如果没有找到自定义的<=>运算符，编译器会尝试合成默认的比较操作。这通常涉及对类的成员变量进行逐一比较。
比较结果转换： 编译器需要将比较结果转换为适当的排序类型（std::strong_ordering、std::weak_ordering或std::partial_ordering）。
合成其他比较运算符： 根据<=>的结果，编译器可以合成其他比较运算符（例如，a < b可以被转换为 (a <=> b) < 0）。

3. 默认比较的优化

默认比较的性能至关重要，尤其是在处理大型对象或频繁比较的场景中。编译器可以采取多种策略来优化默认比较：

内联展开： 将<=>运算符的实现内联到调用点，避免函数调用的开销。
矢量化： 利用SIMD指令，同时比较多个成员变量。
缓存比较结果： 如果比较操作是昂贵的，可以缓存比较结果，避免重复计算。
按成员变量声明顺序比较： 通常按照成员变量声明的顺序进行比较，以便更好地利用缓存和矢量化。
SBO（Small Buffer Optimization）： 对于小型对象，可以将对象的数据直接存储在比较器对象内部，避免额外的内存访问。

下面是一个简单的例子，展示了编译器如何优化默认比较：

struct Point {
    int x;
    int y;
};

// 编译器可以合成类似于下面的operator<=>
std::strong_ordering operator<=>(const Point& a, const Point& b) {
  if (a.x < b.x) return std::strong_ordering::less;
  if (a.x > b.x) return std::strong_ordering::greater;
  if (a.y < b.y) return std::strong_ordering::less;
  if (a.y > b.y) return std::strong_ordering::greater;
  return std::strong_ordering::equal;
}

编译器可以将上述代码内联展开，并利用SIMD指令同时比较x和y，从而提高性能。

4. 自定义类型的设计与<=>

在自定义类型中使用<=>时，需要考虑以下几个方面：

选择合适的排序类型： 根据类型的语义选择合适的排序类型（std::strong_ordering、std::weak_ordering或std::partial_ordering）。
考虑相等性的含义： 确定相等性对你的类型意味着什么。是否需要区分完全相同的对象，或者只需要判断某些关键属性是否相等。
处理特殊情况： 考虑如何处理特殊情况，例如空值、NaN等。
保持一致性： 确保<=>的实现与其他比较运算符（<、>、<=、>=、==、!=）保持一致。

下面是一些自定义类型中使用<=>的例子：

例子 1: 字符串比较

字符串比较通常使用std::weak_ordering，因为两个字符串相等但可能具有不同的编码或大小写。

#include <string>
#include <compare>

struct CaseInsensitiveString {
    std::string str;

    std::weak_ordering operator<=>(const CaseInsensitiveString& other) const {
        // 忽略大小写进行比较
        std::string lower_str1 = str;
        std::string lower_str2 = other.str;
        std::transform(lower_str1.begin(), lower_str1.end(), lower_str1.begin(), ::tolower);
        std::transform(lower_str2.begin(), lower_str2.end(), lower_str2.begin(), ::tolower);

        if (lower_str1 < lower_str2) return std::weak_ordering::less;
        if (lower_str1 > lower_str2) return std::weak_ordering::greater;
        return std::weak_ordering::equivalent;
    }
};

int main() {
  CaseInsensitiveString s1{"hello"};
  CaseInsensitiveString s2{"HELLO"};
  if(s1 == s2) {
    std::cout << "Equal" << std::endl; //输出 Equal
  }
}

例子 2: 浮点数比较

浮点数比较需要处理NaN的情况，因此通常使用std::partial_ordering。

#include <cmath>
#include <compare>

struct FloatWrapper {
    double value;

    std::partial_ordering operator<=>(const FloatWrapper& other) const {
        if (std::isnan(value) || std::isnan(other.value)) {
            return std::partial_ordering::unordered;
        }
        if (value < other.value) return std::partial_ordering::less;
        if (value > other.value) return std::partial_ordering::greater;
        return std::partial_ordering::equivalent;
    }
};

int main() {
    FloatWrapper f1{NAN};
    FloatWrapper f2{1.0};

    if ((f1 <=> f2) == std::partial_ordering::unordered) {
        std::cout << "Unordered" << std::endl; // 输出 "Unordered"
    }
}

例子 3: 复杂对象比较

对于包含多个成员变量的复杂对象，可以逐个比较成员变量，并选择合适的排序类型。

#include <compare>

struct Person {
    std::string name;
    int age;

    std::strong_ordering operator<=>(const Person& other) const {
        if (name < other.name) return std::strong_ordering::less;
        if (name > other.name) return std::strong_ordering::greater;
        if (age < other.age) return std::strong_ordering::less;
        if (age > other.age) return std::strong_ordering::greater;
        return std::strong_ordering::equal;
    }
};

5. 合成其他比较运算符

<=>的一个重要优点是可以方便地合成其他比较运算符。编译器可以根据<=>的结果自动生成<、>、<=、>=、==和!=运算符。

例如，如果定义了a <=> b，那么a < b可以被转换为(a <=> b) < 0。

这种合成机制可以大大简化代码，减少重复劳动，并提高代码的可维护性。

6. 注意事项

一致性： 确保<=>的实现与其他比较运算符保持一致。如果a <=> b == 0，那么a == b应该为真。
异常安全： <=>的实现应该是异常安全的。
性能： 尽量优化<=>的实现，尤其是在处理大型对象或频繁比较的场景中。
标准库类型： 对于标准库类型，通常不需要手动定义<=>，因为标准库已经提供了默认的实现。
编译器支持： 确保你的编译器支持C++20的<=>特性。

7. 代码示例与性能分析

以下是一些代码示例，并附带简单的性能分析（使用std::chrono测量时间）：

#include <iostream>
#include <compare>
#include <chrono>
#include <vector>
#include <algorithm>

struct Data {
    int a;
    int b;
    double c;

    std::strong_ordering operator<=>(const Data& other) const = default; // 使用默认比较
};

int main() {
    std::vector<Data> data1(1000000);
    std::vector<Data> data2(1000000);

    // 初始化数据（省略）

    auto start = std::chrono::high_resolution_clock::now();
    std::sort(data1.begin(), data1.end());
    auto end = std::chrono::high_resolution_clock::now();

    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    std::cout << "排序耗时: " << duration.count() << " ms" << std::endl;

    start = std::chrono::high_resolution_clock::now();
    bool equal = (data1 == data2); // 使用合成的==运算符
    end = std::chrono::high_resolution_clock::now();

    duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    std::cout << "比较耗时: " << duration.count() << " ms" << std::endl;

    return 0;
}

性能分析:

使用default可以告诉编译器自动生成<=>，编译器会进行优化。
std::sort 和 == 运算符的性能会受益于编译器对<=>的优化。
性能测试结果会受到编译器优化、硬件和数据分布的影响。

8. <=>与继承

在继承体系中使用<=>时，需要注意以下几点：

基类<=>： 如果基类定义了<=>，派生类可以选择重载它，或者使用基类的实现。
派生类成员： 如果派生类引入了新的成员变量，需要考虑这些成员变量对比较结果的影响。
虚函数： <=>不能是虚函数。如果需要在运行时根据对象的实际类型进行比较，可以使用访问者模式或其他设计模式。

9. 进一步的优化方向

Profile-Guided Optimization (PGO)： 利用PGO，编译器可以根据程序的实际运行情况，更好地优化<=>的实现。
Auto-Vectorization： 进一步改进自动矢量化技术，以便更好地利用SIMD指令。
编译时计算： 对于某些类型的比较，可以在编译时计算结果，从而提高性能。

掌握三向比较符，代码更简洁强大

C++20的三向比较操作符是一个强大的特性，可以简化比较操作的实现，提高代码的可读性和可维护性。通过深入理解<=>的原理、编译器实现和优化策略，我们可以更好地利用这个特性，编写出更高效、更可靠的代码。理解各种排序类型的含义，为自定义类型选择合适的排序方式，并注意一致性、异常安全和性能，是有效使用<=>的关键。

更多IT精英技术系列讲座，到智猿学院

C++20 三向比较操作符（<=>）：编译器实现、优化与自定义类型设计

发表回复 取消回复

发表回复取消回复