Comparison operators

Compares the arguments.

Two-way comparison

The two-way comparison operator expressions have the form.

In all cases, for the built-in operators, lhs and rhs must have either.

• arithmetic or enumeration type (see arithmetic comparison operators below)
• pointer type (see pointer comparison operators below)

after the application of the lvalue-to-rvalue, array-to-pointer and function-to-pointer standard conversions. The comparison is deprecated if both operands have array type prior to the application of these conversions. (since C++20).

In any case, the result is a bool prvalue.

Arithmetic comparison operators

If the operands have arithmetic or enumeration type (scoped or unscoped), usual arithmetic conversions are performed on both operands following the rules for arithmetic operators. The values are compared after conversions:

Example

#include <iostream>
 
int main()
{
    static_assert(sizeof(unsigned char) < sizeof(int),
                  "Can't 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"
        << " -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' // may issue different-signedness warning
        << "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

Pointer comparison operators

Comparison operators can be used to compare two pointers.

Only equality operators (operator== and operator!=) can be used to compare the following pointer pairs:

• two pointers-to-members
• a null pointer constant with a pointer or a pointer-to-member

First, pointer conversions (pointer to member conversions if the arguments are pointers to members), function pointer conversions, (since C++17) and qualification conversions are applied to both operands to obtain the composite pointer type, as follows:

void

• P1, a pointer to (possibly cv-qualified) T1, and
• P2, a pointer to (possibly cv-qualified) T2,

• MP1, pointer to member of T1 of type (possibly cv-qualified) U1, and
• MP2, pointer to member of T2 of type (possibly cv-qualified) U2,

In the definition above, cv-combined type of two pointer types P1 and P2 is a type P3 that has the same number of levels and type at every level as P1, except that cv-qualifications at every level are set as follows:

const

For example, the composite pointer type of void* and const int* is const void*. The composite pointer type of int** and const int** is const int* const*. Note that until the resolution of CWG issue 1512 (N3624), int** and const int** could not be compared.

Note that this implies that any pointer can be compared with void*.

The result of comparing two pointers to objects (after conversions) is defined as follows:

The result of equality comparison of two pointers (after conversions) is defined as follows:

The result of comparing two pointers to members (after conversions) is defined as follows:

struct A {};
struct B : A { int x; };
struct C : A { int x; };
 
int A::*bx = (int(A::*)) &B::x;
int A::*cx = (int(A::*)) &C::x;
 
bool b1 = (bx == cx); // unspecified

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

If a pointer p compare equal to pointer q, p <= q and p >= q both yield true and p < q and p > q both yield false.

If a pointer p compares greater than a pointer q, then p >= q, p > q, q <= p, and q < p all yield true and p <= q, p < q, q >= p, and q > p all yield false.

If two pointers are not specified to compare greater or compare equal, the result of the comparison is unspecified. An unspecified result may be nondeterministic, and need not be consistent even for multiple evaluations of the same expression with the same operands in the same execution of the program:

int x, y;
 
bool f(int* p, int* q) { return p < q; }
 
assert(f(&x, &y) == f(&x, &y)); // may fire in a conforming implementation

In overload resolution against user-defined operators, for every pair of promoted arithmetic types L and R, including enumeration types, the following function signatures participate in overload resolution:

bool operator<(L, R);

bool operator>(L, R);

bool operator<=(L, R);

bool operator>=(L, R);

bool operator==(L, R);

bool operator!=(L, R);

For every type P which is either pointer to object or pointer to function, the following function signatures participate in overload resolution:

bool operator<(P, P);

bool operator>(P, P);

bool operator<=(P, P);

bool operator>=(P, P);

bool operator==(P, P);

bool operator!=(P, P);

For every type MP that is a pointer to member object or pointer to member function or std::nullptr_t, the following function signatures participate in overload resolution:

bool operator==(MP, MP);

bool operator!=(MP, MP);

Example

#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:\n"
              << "p1 == p2? " << (p1 == p2) << '\n'
              << "p1 <  p2? " << (p1 <  p2) << '\n';
 
    Foo f;
    int* p3 = &f.n1;
    int* p4 = &f.n2;
    std::cout << "Pointers to members of a class:\n"
              << "p3 == p4? " << (p3 == p4) << '\n'
              << "p3 <  p4? " << (p3 <  p4) << '\n';
 
    Union u;
    int* p5 = &u.n;
    double* p6 = &u.d;
    std::cout << "Pointers to members of a union:\n"
              << "p5 == (void*)p6? " << (p5 == (void*)p6) << '\n'
              << "p5 <  (void*)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 <  (void*)p6? false

Notes

Because these operators group left-to-right, the expression a < b < c is parsed (a < b) < c, and not a < (b < c) or (a < b) && (b < c).

#include <iostream>
 
int main()
{
    int a = 3, b = 2, c = 1;
 
    std::cout << std::boolalpha
        << (a < b < c) << '\n' // true; maybe warning
        << ((a < b) < c) << '\n' // true
        << (a < (b < c)) << '\n' // false
        << ((a < b) && (b < c)) << '\n'; // false
}

A common requirement for user-defined operator< is strict weak ordering. In particular, this is required by the standard algorithms and containers that work with Compare types: std::sort, std::max_element, std::map, etc.

Although the results of comparing pointers of random origin (e.g. not all pointing to members of the same array) is unspecified, many implementations provide strict total ordering of pointers, e.g. if they are implemented as addresses within continuous virtual address space. Those implementations that do not (e.g. where not all bits of the pointer are part of a memory address and have to be ignored for comparison, or an additional calculation is required or otherwise pointer and integer is not a 1 to 1 relationship), provide a specialization of std::less for pointers that has that guarantee. This makes it possible to use all pointers of random origin as keys in standard associative containers such as std::set or std::map.

For the types that are both EqualityComparable and LessThanComparable, the C++ standard library makes a distinction between equality, which is the value of the expression a == b and equivalence, which is the value of the expression !(a < b) && !(b < a).

Comparison between pointers and null pointer constants was removed by the resolution of CWG issue 583 included in N3624:

void f(char* p)
{
    if (p > 0) { /*...*/ } // Error with N3624, compiled before N3624
    if (p > nullptr) { /*...*/ } // Error with N3624, compiled before N3624
}
 
int main() {}

R operator<=>(T, T);

#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

unsigned int i = 1;
auto r = -1 < i;    // existing pitfall: returns ‘false’
auto r2 = -1 <=> i; // Error: narrowing conversion required

Standard library

Comparison operators are overloaded for many classes in the standard library.

The namespace std::rel_ops provides generic operators !=, >, <=, and >=:

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

See also

• Operator precedence
• Operator overloading
• Compare (named requirements)