Comparison operators

比较参数。

双向比较

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

关系运算符

相等运算符

内置双向比较运算符

对于内置的双向比较运算符， 左值到右值转换 、 数组到指针转换 (直至 C++26) 以及 函数到指针转换 会被应用于 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 起) 和 限定转换 ，以使它们达到其 复合指针类型 。随后按以下方式比较复合指针类型的两个指向成员的指针：

• 如果两个成员指针都是空成员指针值，则它们比较相等。
• 如果两个成员指针中仅有一个是空成员指针值，则它们比较不相等。
• 如果任意一个是指向 虚成员函数 的指针，则结果未指定。
• 如果一个指向类 C1 的成员，另一个指向不同类 C2 的成员，且这两个类互不为基类，则结果未指定。
• 如果两个指针都指向同一 联合体 的（可能不同的）成员，则它们比较相等。
• 否则，如果通过关联类类型的假设对象进行间接寻址时，两个成员指针会指向同一 最终派生对象 的同一成员或同一子对象，则它们比较相等，否则比较不相等。

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 （或其子对象），另一个指针指向 low （或其子对象），则前者比较结果大于后者。
• 若一个指针指向数组元素 elem （或其子对象），而另一个指针指向同一数组的尾后位置，则尾后指针的比较结果大于另一个指针。
• 若一个指针指向完整对象、基类子对象或成员子对象 obj （或其子对象），而另一个指针指向 obj 的尾后位置，则尾后指针的比较结果大于另一个指针。

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

指针全序

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

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

• 调用 operator ( ) 的指针类型特化版本： std::less 、 std::greater 、 std::less_equal 和 std::greater_equal 。

重载

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

对于每个类型 P ，若其为对象指针或函数指针，下列函数签名将参与重载决议：

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

#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 。

对于同时满足 可相等比较 和 可小于比较 的类型，C++标准库对 相等性 （即表达式 a == b 的值）与 等价性 （即表达式 ! ( a < b ) && ! ( b < a ) 的值）进行了明确区分。

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

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

三路比较可为类类型自动生成，详见 默认比较 。

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

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

标准库

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

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

缺陷报告

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

参见

• 运算符优先级
• 运算符重载
• Compare (命名要求)