Comparison operators

比较参数。

双向比较

双向比较运算符表达式的形式为

关系运算符

相等运算符

内置双向比较运算符

对于内置的双向比较运算符， lvalue-to-rvalue conversions ， array-to-pointer conversions (until C++26) 和 function-to-pointer conversions 会被应用于 lhs 和 rhs 。

对于内置的双向比较运算符，其结果为 bool 纯右值。

内置算术比较

如果转换后的两个操作数都具有算术或枚举类型（有作用域或无作用域）， 常规算术转换 将作用于两个操作数。转换后的值将进行比较：

#include <iostream>
int main()
{
    static_assert(sizeof(unsigned char) < sizeof(int),
                  "Cannot compare signed and smaller unsigned properly");
    int a = -1;
    int b = 1;
    unsigned int c = 1;
    unsigned char d = 1;
    std::cout << std::boolalpha
              << "Comparing two signed values:\n"
                 " -1 == 1 ? " << (a == b) << "\n"
                 " -1 <  1 ? " << (a <  b) << "\n"
                 " -1 >  1 ? " << (a >  b) << "\n"
                 "Comparing signed and unsigned:\n"
                 // may issue different-signedness warning:
                 " -1 == 1 ? " << (a == c) << "\n"
                 // may issue different-signedness warning:
                 " -1 <  1 ? " << (a <  c) << "\n"
                 // may issue different-signedness warning:
                 " -1 >  1 ? " << (a >  c) << "\n"
                 "Comparing signed and smaller unsigned:\n"
                 " -1 == 1 ? " << (a == d) << "\n"
                 " -1 <  1 ? " << (a <  d) << "\n"
                 " -1 >  1 ? " << (a >  d) << '\n';
}

Comparing two signed values:
 -1 == 1 ? false
 -1 <  1 ? true
 -1 >  1 ? false
Comparing signed and unsigned:
 -1 == 1 ? false
 -1 <  1 ? false
 -1 >  1 ? true
Comparing signed and smaller unsigned:
 -1 == 1 ? false
 -1 <  1 ? true
 -1 >  1 ? false

内置指针相等性比较

相等运算符 == 和 != 转换后的操作数也可以具有 类型 std::nullptr_t ， (C++11 起) 指针类型或成员指针类型。

内置指针相等性比较具有三种可能结果：相等、不相等和未指定。以下是内置指针相等性比较中相等运算符所产生值的列表：

如果转换后的 lhs 和 rhs 中至少有一个是指针， 则会执行 指针转换 、 函数指针转换 (C++17 起) 以及 限定转换 ，使两个转换后的操作数达到其 复合指针类型 。随后按以下方式比较复合指针类型的两个指针：

• 如果一个指针 表示完整对象的地址 ，而另一个指针

• 表示不同完整非数组对象末尾之后地址，或
• 表示不同完整数组对象最后一个元素之后地址，

则比较结果未指定。

• 否则，如果两个指针均为空指针、指向同一函数，或表示同一地址（即它们指向或超越同一对象的末尾），则它们比较相等。
• 否则，指针比较结果为不相等。

如果转换后的 lhs 和 rhs 中至少有一个是指向成员的指针，则对两个转换后的操作数执行 指向成员指针转换 、 函数指针转换 （自 C++17 起） 以及 限定转换 ，以使它们达到其 复合指针类型 。随后按以下方式比较复合指针类型的两个指向成员指针：

• 若两个成员指针均为空成员指针值，则它们比较相等。
• 若两个成员指针中仅有一个为空成员指针值，则它们比较不相等。
• 若其中任意一个是指向 virtual member function 的指针，则结果未指定。
• 若一个指向类 C1 的成员，而另一个指向不同类 C2 的成员（且二者互不为基类），则结果未指定。
• 若两者均指向同一 union 的（可能不同的）成员，则它们比较相等。
• 否则，当通过关联类类型的假设对象进行间接寻址时，若两个成员指针会指向同一 most derived object 或同一子对象的相同成员，则它们比较相等；否则比较不相等。

struct P {};
struct Q : P { int x; };
struct R : P { int x; };
int P::*bx = (int(P::*)) &Q::x;
int P::*cx = (int(P::*)) &R::x;
bool b1 = (bx == cx); // 未指定
struct B
{
    int f();
};
struct L : B {};
struct R : B {};
struct D : L, R {};
int (B::*pb)() = &B::f;
int (L::*pl)() = pb;
int (R::*pr)() = pb;
int (D::*pdl)() = pl;
int (D::*pdr)() = pr;
bool x = (pdl == pdr); // false
bool y = (pb == pl);   // true

内置指针关系比较

关系运算符 > 、 < 、 >= 和 <= 转换后的操作数也可以具有指针类型。

对不相等指针 p 和 q 进行内置指针关系比较时存在三种可能结果： p 较大、 q 较大以及未指定结果。内置指针关系比较中关系运算符所生成的取值如下所示：

如果转换后的 lhs 和 rhs 均为指针类型， 将对其执行 指针转换 、 函数指针转换 (C++17 起) 以及 限定转换 ，使其转换为对应的 复合指针类型 。复合指针类型的两个指针将按以下方式进行比较：

• 若指针比较相等或相等比较结果未指定，则关系比较结果属于同一类别。
• 否则（指针比较不相等），若任一指针不是指向对象的指针，则结果未指定。
• 否则（两个指针均指向对象），结果按符合以下规则的部分顺序定义：

• 给定数组中的两个不同元素 high 和 low ，其中 high 的下标高于 low ，若一个指针指向 high （或 high 的子对象），而另一个指针指向 low （或 low 的子对象），则前者比较结果大于后者。
• 若一个指针指向数组元素 elem （或 elem 的子对象），而另一个指针指向同一数组的尾后位置，则尾后指针的比较结果大于另一个指针。
• 若一个指针指向完整对象、基类子对象或成员子对象 obj （或 obj 的子对象），而另一个指针指向 obj 的尾后位置，则尾后指针的比较结果大于另一个指针。

• 如果指针指向同一非联合类类型对象的不同 非零大小 (C++20 起) 非静态数据成员 且具有相同 成员访问权限 (C++23 前) ，或递归指向这些成员的子对象，则指向后声明成员的指针比较结果大于另一指针。
• 否则，结果未指定。

指针全序

在每个程序中存在一个 实现定义的指针严格全序 。该严格全序与上述偏序保持一致：未指定的结果变为实现定义，而其他结果保持不变。

严格全序的指针比较适用于以下情况：

• 调用 operator ( ) 指针类型特化的 std::less 、 std::greater 、 std::less_equal 和 std::greater_equal 的运算符。

双向比较运算符的重载

重载

在 针对用户定义运算符的重载决议 中，对于每一对提升后的算术类型 L 和 R （包括枚举类型），以下函数签名会参与重载决议：

对于每个类型 P （该类型为指向对象或指向函数的指针），以下函数签名参与重载决议：

对于每个类型 MP ，若其为指向成员对象的指针或指向成员函数的指针 或 std::nullptr_t (C++11 起) ，以下函数签名会参与重载决议：

#include <iostream>
struct Foo
{
    int n1;
    int n2;
};
union Union
{
    int n;
    double d;
};
int main()
{
    std::cout << std::boolalpha;
    char a[4] = "abc";
    char* p1 = &a[1];
    char* p2 = &a[2];
    std::cout << "指向数组元素的指针：\n"
              << "p1 == p2? " << (p1 == p2) << '\n'
              << "p1 <  p2? " << (p1 <  p2) << '\n';
    Foo f;
    int* p3 = &f.n1;
    int* p4 = &f.n2;
    std::cout << "指向类成员的指针：\n"
              << "p3 == p4? " << (p3 == p4) << '\n'
              << "p3 <  p4? " << (p3 <  p4) << '\n';
    Union u;
    int* p5 = &u.n;
    double* p6 = &u.d;
    std::cout << "指向联合体成员的指针：\n"
              << "p5 == (void*)p6? " << (p5 == (void*)p6) << '\n'
              << "p5 <  (void*)p6? " << (p5 <  (void*)p6) << '\n';
}

指向数组元素的指针：
p1 == p2? false
p1 <  p2? true
指向类成员的指针：
p3 == p4? false
p3 <  p4? true
指向联合体成员的指针：
p5 == (void*)p6? true
p5 <  (void*)p6? false

#include <compare>
#include <iostream>
int main()
{
    double foo = -0.0;
    double bar = 0.0;
    auto res = foo <=> bar;
    if (res < 0)
        std::cout << "-0 is less than 0";
    else if (res > 0)
        std::cout << "-0 is greater than 0";
    else if (res == 0)
        std::cout << "-0 and 0 are equal";
    else
        std::cout << "-0 and 0 are unordered";
}

-0 and 0 are equal

注释

由于比较运算符采用从左到右的分组方式，表达式 a < b < c 会被解析为 ( a < b ) < c ，而非 a < ( b < c ) 或 ( a < b ) && ( b < c ) 。

#include <iostream>
int main()
{
    int a = 3, b = 2, c = 1;
    std::cout << std::boolalpha
        << (a < b < c) << '\n' // true; 可能产生警告
        << ((a < b) < c) << '\n' // true
        << (a < (b < c)) << '\n' // false
        << ((a < b) && (b < c)) << '\n'; // false
}

对于 用户自定义的 operator< 而言，一个常见的要求是实现 严格弱序 。特别地，标准算法和容器在处理 Compare 类型时需要满足这一要求： std::sort 、 std::max_element 、 std::map 等。

指向同一类不同非静态数据成员的 指针比较结果 表明，非静态数据成员 在三种 成员访问模式 (until C++23) 下均按声明顺序在内存中排列。

尽管比较随机来源的指针（例如并非全部指向同一数组成员）的结果是未指定的，但许多实现提供了指针的 严格全序 关系，例如当指针被实现为连续虚拟地址空间中的地址时。那些不提供此类保证的实现（例如指针并非所有位都表示内存地址且比较时需要忽略某些位，或需要额外计算，或指针与整数非一一对应关系），会为指针提供特化版本的 std::less 以满足该保证。这使得所有随机来源的指针都可以用作标准关联容器（如 std::set 或 std::map ）的键值。

对于同时满足 EqualityComparable 和 LessThanComparable 要求的类型，C++标准库区分了 相等性 （即表达式 a == b 的值）与 等价性 （即表达式 ! ( a < b ) && ! ( b < a ) 的值）。

指针与空指针常量之间的比较已通过 CWG issue 583 的解决方案被移除，该方案包含在 N3624 中：

void f(char* p)
{
    if (p > 0) { /*...*/ } // 使用 N3624 时报错，N3624 前可编译
    if (p > nullptr) { /*...*/ } // 使用 N3624 时报错，N3624 前可编译
}
int main() {}

三路比较可为类类型自动生成，参见 default comparisons 。

如果两个操作数都是数组，三路比较将无法形成有效表达式。

unsigned int i = 1;
auto r = -1 < i;    // 现有陷阱：返回‘false’
auto r2 = -1 <=> i; // 错误：需要窄化转换

标准库

标准库中的许多类都重载了比较运算符。

命名空间 std::rel_ops 提供通用运算符 ! = 、 > 、 <= 和 >= ：

缺陷报告

以下行为变更缺陷报告被追溯应用于先前发布的 C++ 标准。

另请参阅

• 运算符优先级
• 运算符重载
• Compare （命名要求）