比较运算符

比较参数。

双路比较

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

所有情况下，对于内建运算符，lhs 和 rhs 在应用左值到右值、数组到指针和函数到指针标准转换后，必须具有下列类型之一

• 算术或枚举类型（见下文的算术比较运算符）
• 指针类型（见下文的指针比较运算符）

若两个运算数在应用这些转换前均具有数组类型，则这种比较被弃用。 (C++20 起)

任何情况下，结果均为 bool 纯右值。

算术比较运算符

如果两个操作数具有算术或（有作用域或无作用域）枚举类型，则遵循算术运算符的规则，对两个操作数实施一般算术转换。转换之后进行值的比较：

示例

#include <iostream>
int main()
{
    std::cout << std::boolalpha;
    int n = -1;
 
    int n2 = 1;
    std::cout << " -1 == 1? " << (n == n2) << '\n'
              << "Comparing two signed values:\n"
              << " -1  < 1? " << (n < n2) << '\n'
              << " -1  > 1? " << (n > n2) << '\n';
 
    unsigned int u = 1;
    std::cout << "Comparing signed and unsigned:\n"
              << " -1  < 1? " << (n < u) << '\n'
              << " -1  > 1? " << (n > u) << '\n';
 
    unsigned char uc = 1;
    std::cout << "Comparing signed and smaller unsigned:\n"
              << " -1  < 1? " << (n < uc) << '\n'
              << " -1  > 1? " << (n > uc) << '\n';
}

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

指针比较运算符

比较运算符可用于比较二个指针（或成员指针，但仅对于 operator== 和 operator!=），或一个（成员） (C++14 起)指针和一个空指针常量，或两个空指针常量（但要至少一个为 std::nullptr_t：NULL 和 NULL 的比较遵循算术比较规则） (C++14 前)。

首先，对两个操作数应用指针转换（若参数为成员指针则为成员指针转换）、函数指针转换 (C++17 起)和限定性转换，以获得合成指针类型，规则如下

注意这意味着任何指针都能与 void* 进行比较。

两个对象指针（转换后）的比较结果定义如下：

两个（转换后）指针的相等性比较的结果定义如下：

两个（转换后）成员指针的比较结果定义如下：

若指针 p 比较等于指针 q，则 p<=q å’Œ p>=q 都产出 true 而 p<q å’Œ p>q 都产出 false。

若指针 p 比较大于指针 q，则 p>=q、p>q、q<=p å’Œ q<p 都产出 true 而 p<=q、p<q、q>=p å’Œ q>p 都产出 false。

若未指明两个指针的比较大于或比较相等，则其比较结果未指明。其结果可以是不确定的，并且甚至不必在程序的同一次执行中，在拥有相同操作数的相同表达式的多次求值之间保持一致：

int x, y;
 
bool f(int* p, int* q) { return p < q; }
 
assert(f(&x, &y) == f(&x, &y)); // 在遵从标准的实现中可能引发断言

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

对于每个对象指针或函数指针或 std::nullptr_t (C++14 前)的类型 P，下列函数签名参与重载决议：

对于每个为成员对象指针或成员函数指针或 std::nullptr_t 的类型 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 << "Pointers to array elements: p1 == p2 " << (p1 == p2)
              << ", p1 < p2 "  << (p1 < p2) << '\n';
 
    Foo f;
    int* p3 = &f.n1;
    int* p4 = &f.n2;
    std::cout << "Pointers to members of a class: p3 == p4 " << (p3 == p4)
              << ", p3 < p4 "  << (p3 < p4) << '\n';
 
    Union u;
    int* p5 = &u.n;
    double* p6 = &u.d;
    std::cout << "Pointers to members of a union: p5 == (void*)p6 " << (p5 == (void*)p6)
              << ", p5 < p6 "  << (p5 < (void*)p6) << '\n';
}

Pointers to array elements: p1 == p2 false, p1 < p2 true
Pointers to members of a class: p3 == p4 false, p3 < p4 true
Pointers to members of a union: p5 == (void*)p6 true, p5 < p6 false

注解

因为这些运算符从左到右组合，故表达式 a<b<c 被分析为 (a<b)<c，而非 a<(b<c) 或 (a<b)&&(b<c)。

对用户定义的 operator< 的一项常见要求是严格弱序。尤其是，用比较 (Compare) 类型进行工作的标准算法和容器如 std::sort、std::max_element、std::map 等都对此有所要求。

尽管未指明对随机来源（例如不都指向同一数组中的成员）的指针比较的结果，许多实现都提供指针的严格全序，例如若它们被实现为连续的虚拟地址空间中的地址。不这样做的实现（例如并非指针的所有位都是内存地址的一部分而在比较中必须被忽略，或要求进行额外的计算否则指针与整数并非 1 对 1 关系），要为指针提供具有这项保证的 std::less 的特化。这使得程序可以将随机来源的所有指针都用作标准关联容器（如 std::set 或 std::map）的键。

对于既可相等比较 (EqualityComparable) 又可小于比较 (LessThanComparable) 的类型，C++ 标准库在相等（即表达式 a == b 的值），和等价（即表达式 !(a < b) && !(b < a) 的值）之间做出区别。

C++14 中移除了指针与空指针常量间的比较。

void f(char * p)
{
  if (p > 0) { ... } // C++98..C++11 中 OK，C++14 中不能编译
  if (p > nullptr) { ... } // C++11 中 OK，C++14 中不能编译
}

unsigned int i = 1;
auto r = -1 < i; // 既存陷阱：返回 false
auto r2 = -1 <=> i; // 错误：要求窄化转换

标准库

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

命名空间 rel_ops 提供了泛型运算符 !=、>、<= 及 >=

参阅

运算符优先级

运算符重载