比较参数。

双路比较

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

1) 若 lhs 小于 rhs 则返回 true，否则返回 false。

2) 若 lhs 大于 rhs 则返回 true，否则返回 false。

3) 若 lhs 小于或等于 rhs 则返回 true，否则返回 false。

4) 若 lhs 大于或等于 rhs 则返回 true，否则返回 false。

5) 若 lhs 等于 rhs 则返回 true，否则返回 false。

6) 若 lhs 不等于 rhs 则返回 true，否则返回 false。

所有情况下，对于内建运算符，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 起)和限定性转换，以获得合成指针类型，规则如下

1) 若两个操作数均为空指针常量，则合成指针类型为 std::nullptr_t

2) 若一个操作数为空指针常量，而另一个为指针，则合成类型正是该指针类型

3) 若一个操作数为指向 cv1 void 的指针，而另一个为（对于某类型 T）指向 cv2 T 的指针，其中 T 为对象类型或 void，则合成类型为“指向 cv12 void 的指针”，其中 cv12 为 cv1 与 cv2 的合并

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

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

1) 若两个指针指向同一数组的不同元素，或同一数组的不同元素内的子对象，则指向拥有较高下标的元素的指针比较大于另一指针。换言之，比较指针的结果与比较其所指向的元素下标结果相同。

2) 若一个指针指向数组元素，或数组元素的子对象，而另一指针指向数组末尾元素后一位置，则后者比较大于前者。指向单个对象的指针被当做指向单元素数组的指针：&obj+1 比较大于 &obj。 (C++17 起)

3) 若在非联合体类类型的对象内，两个指针指向拥有相同成员访问的不同非静态数据成员，或（递归地）指向这种成员的子对象或数组元素，则指向较后声明的成员的指针比较大于另一指针。换言之，三个成员访问模式的每一者中的类成员按声明顺序置于内存中。

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

1) 若两个指针均为空指针值，则它们比较相等

2) 若两个指针均为函数指针且指向同一函数，则它们比较相等

3) 若两个指针均为对象指针且表示相同地址，则它们比较相等（这包括两个指向同一联合体的不同非静态成员的指针，指向标准布局结构体与其首成员的指针，由 reinterpret_cast 关联的指针等）

4) 所有其他指针的比较不相等。

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

1) 若两个成员指针均为空成员指针值，则它们比较相等。

2) 否则，若两个成员指针之一为空成员指针值，则它们比较不相等。

3) 否则，若其中之一为指向虚成员函数的指针，则结果未指明。

4) 否则，当且仅当以一个其关联类类型的假想对象对它们解引用时，它们会指代同一最终派生对象或同一子对象的相同成员，两个成员指针相等。

5) 否则它们的比较不相等。

若指针 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 提供了泛型运算符 !=、>、<= 及 >=

运算符优先级

运算符重载