Compares the arguments.

[edit]Two-way comparison

The two-way comparison operator expressions have the form

[edit]Relational operators

[edit]Equality operators

[edit]Built-in two-way comparison operators

For built-in two-way comparison operators,lvalue-to-rvalue conversions,array-to-pointer conversions(until C++26) andfunction-to-pointer conversions are applied tolhs andrhs .

For built-in two-way comparison operators, the result is abool prvalue.

[edit]Built-in arithmetic comparison

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

#include <iostream> int main(){    static_assert(sizeof(unsignedchar)< sizeof(int),"Cannot compare signed and smaller unsigned properly");int a=-1;int b=1;unsignedint c=1;unsignedchar 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 ? falseComparing signed and unsigned: -1 == 1 ? false -1 <  1 ? false -1 >  1 ? trueComparing signed and smaller unsigned: -1 == 1 ? false -1 <  1 ? true -1 >  1 ? false

[edit]Built-in pointer equality comparison

The converted operands of equality operators== and!= can also have the typestd::nullptr_t,(since C++11) pointer type or pointer-to-member type.

Built-in pointer equality comparison has three possible results: equal, unequal and unspecified. The values yielded by equality operators for built-in pointer equality comparison is listed below:

If at least one of convertedlhs andrhs is a pointer,pointer conversions,function pointer conversions(since C++17) andqualification conversions are performed on both converted operands to bring them to theircomposite pointer type. The two pointers of the composite pointer type are compared as follows:

• If one pointerrepresents the address of a complete object, and another pointer

• represents the address past the end of a different complete non-array object, or
• represents the address one past the last element of a different complete array object,

the result of the comparison is unspecified.

• Otherwise, if the pointers are both null, both point to the same function, or both represent the same address (i.e., they point to or are past the end of the same object), they compare equal.
• Otherwise, the pointers compare unequal.

If at least one of convertedlhs andrhs is a pointer to member,pointer-to-member conversions,function pointer conversions(since C++17) andqualification conversions are performed on both converted operands to bring them to theircomposite pointer type. The two pointers to members of the composite pointer type are compared as follows:

• If two pointers to members are both the null member pointer value, they compare equal.
• If only one of two pointers to members is the null member pointer value, they compare unequal.
• If either is a pointer to avirtual member function, the result is unspecified.
• If one refers to a member of classC1 and the other refers to a member of a different classC2, where neither is a base class of the other, the result is unspecified.
• If both refer to (possibly different) members of the sameunion, they compare equal.
• Otherwise, two pointers to members compare equal if they would refer to the same member of the samemost derived object or the same subobject if indirection with a hypothetical object of the associated class type were performed, otherwise they compare unequal.

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);// 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);// falsebool y=(pb== pl);// true

[edit]Built-in pointer relational comparison

The converted operands of relational operators>,<,>= and<= can also have pointer type.

Built-in pointer relational comparison on unequal pointersp andq has three possible results:p is greater,q is greater and unspecified. The values yielded by relational operators for built-in pointer relational comparison is listed below:

If convertedlhs andrhs are both pointers,pointer conversions,function pointer conversions(since C++17) andqualification conversions are performed on both converted operands to bring them to theircomposite pointer type. The two pointers of the composite pointer type are compared as follows:

• If the pointers compare equal or the equality comparison result is unspecified, the relational comparison result falls into the same category.
• Otherwise (the pointers compare unequal), if any of the pointers is not a pointer to object, the result is unspecified.
• Otherwise (both pointers point to objects), the result is defined in terms of a partial order consistent with the following rules:

• Given two different elementshigh andlow of an array such thanhigh has higher subscript thanlow, if one pointer points tohigh (or a subobject ofhigh) and the other pointer points tolow (or a subobject oflow), the former compares greater than the latter.
• If one pointer points to an elementelem (or to a subobject ofelem) of an array, and the other pointer is past the end of the same array, the past-the-end pointer compares greater than the other pointer.
• If one pointer points to a complete object, a base class subobject or a member subobjectobj (or to a subobject ofobj), and the other pointer is past the end ofobj, the past-the-end pointer compares greater than the other pointer.

• If the pointers point to differentnon-zero-sized(since C++20) non-static data members with the samemember access(until C++23) of the same object of a non-union class type, or to subobjects of such members, recursively, the pointer to the later declared member compares greater than the other pointer.
• Otherwise, the result is unspecified.

[edit]Pointer total order

There exists animplementation-defined strict total order over pointers in each program. The strict total order is consistent with the partial order described above: unspecified results become implementation-defined, while other results stay the same.

Pointer comparison with the strict total order is applied in the following cases:

• Calling theoperator() of the pointer type specializations ofstd::less,std::greater,std::less_equal, andstd::greater_equal.

[edit]Overloads

Inoverload resolution against user-defined operators, for every pair of promoted arithmetic typesL andR, including enumeration types, the following function signatures participate in overload resolution:

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

For every typeMP that is a pointer to member object or pointer to member function orstd::nullptr_t(since C++11), the following function signatures participate in overload resolution:

#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? falsep1 <  p2? truePointers to members of a class:p3 == p4? falsep3 <  p4? truePointers to members of a union:p5 == (void*)p6? truep5 <  (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";elseif(res>0)std::cout<<"-0 is greater than 0";elseif(res==0)std::cout<<"-0 and 0 are equal";elsestd::cout<<"-0 and 0 are unordered";}

-0 and 0 are equal

[edit]Notes

Because comparison operators group left-to-right, the expressiona< b< c is parsed(a< b)< c, and nota<(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 foruser-defined operator< isstrict weak ordering. In particular, this is required by the standard algorithms and containers that work withCompare types:std::sort,std::max_element,std::map, etc.

Thecomparison result of pointers to different non-static data members of the same class implies that non-static data members in each of the threemember access modes(until C++23) are positioned in memory in order of declaration.

Although the results of comparing pointers of random origin (e.g. not all pointing to members of the same array) is unspecified, many implementations providestrict 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 ofstd::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 asstd::set orstd::map.

For the types that are bothEqualityComparable andLessThanComparable, the C++ standard library makes a distinction betweenequality, which is the value of the expressiona== b andequivalence, which is the value of the expression!(a< b)&&!(b< a).

Comparison between pointers and null pointer constants was removed by the resolution ofCWG issue 583 included inN3624:

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

Three-way comparison can be automatically generated for class types, seedefault comparisons.

If both of the operands are arrays, three-way comparison is ill-formed.

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

[edit]Standard library

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

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

[edit]Defect reports

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

[edit]See also

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

• In other languages

• Deutsch
• Español
• Français
• Italiano
• 日本語
• Português
• Русский
• 中文