operator==,!=,<,<=,>,>=,<=>(std::pair)

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++11)

Technical specifications

Symbols index

External libraries

 

Utilities library

Language support Type support (basic types, RTTI) Library feature-test macros (C++20) Dynamic memory management launder (C++17) Program utilities Coroutine support (C++20) Variadic functions is_constant_evaluated (C++20) initializer_list (C++11) source_location (C++20) Three-way comparison (C++20) three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)    is_eqis_neqis_ltis_lteqis_gtis_gteq (C++20)(C++20)(C++20)(C++20)(C++20)(C++20)

General utilities Date and time Function objects Formatting library (C++20) bitset hash (C++11) Relational operators (deprecated in C++20) rel_ops::operator!=rel_ops::operator> rel_ops::operator<=rel_ops::operator>= Integer comparison functions cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)    cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Swap and type operations swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Common vocabulary types pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23) Elementary string conversions to_chars (C++17) from_chars (C++17) chars_format (C++17)

 

std::pair

Member functions

pair::pair

pair::operator=

pair::swap (C++11)

Non-member functions

make_pair

operator==operator!=operator<operator<=operator>operator>=operator<=> (until C++20)(until C++20)(until C++20)(until C++20)(until C++20)(C++20)

std::swap (C++11)

get (C++11)

Deduction guides(C++17)

Helper classes

tuple_size (C++11)

tuple_element (C++11)

basic_common_reference (C++23)

common_type (C++23)

 

Defined in header <utility>
	(1)
template< class T1, class T2, class U1, class U2 > bool operator==( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );			(until C++14)
template< class T1, class T2, class U1, class U2 > constexpr bool operator==( const std::pair<T1, T2>& lhs,                            const std::pair<U1, U2>& rhs );			(since C++14)
		(2)
template< class T1, class T2, class U1, class U2 > bool operator!=( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );				(until C++14)
template< class T1, class T2, class U1, class U2 > constexpr bool operator!=( const std::pair<T1, T2>& lhs,                            const std::pair<U1, U2>& rhs );				(since C++14) (until C++20)
			(3)
template< class T1, class T2, class U1, class U2 > bool operator<( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );					(until C++14)
template< class T1, class T2, class U1, class U2 > constexpr bool operator<( const std::pair<T1, T2>& lhs,                           const std::pair<U1, U2>& rhs );					(since C++14) (until C++20)
				(4)
template< class T1, class T2, class U1, class U2 > bool operator<=( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );						(until C++14)
template< class T1, class T2, class U1, class U2 > constexpr bool operator<=( const std::pair<T1, T2>& lhs,                            const std::pair<U1, U2>& rhs );						(since C++14) (until C++20)
					(5)
template< class T1, class T2, class U1, class U2 > bool operator>( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );							(until C++14)
template< class T1, class T2, class U1, class U2 > constexpr bool operator>( const std::pair<T1, T2>& lhs,                           const std::pair<U1, U2>& rhs );							(since C++14) (until C++20)
						(6)
template< class T1, class T2, class U1, class U2 > bool operator>=( const std::pair<T1, T2>& lhs, const std::pair<U1, U2>& rhs );								(until C++14)
template< class T1, class T2, class U1, class U2 > constexpr bool operator>=( const std::pair<T1, T2>& lhs,                            const std::pair<U1, U2>& rhs );								(since C++14) (until C++20)
template< class T1, class T2, class U1, class U2 > constexpr /* see below */ operator<=>( const std::pair<T1, T2>& lhs,                                        const std::pair<U1, U2>& rhs );							(7)	(since C++20)

1-2) Tests if both elements of lhs and rhs are equal, that is, compares lhs.first with rhs.first and lhs.second with rhs.second.

3-6) Compares lhs and rhs lexicographically by operator<, that is, compares the first elements and only if they are equivalent, compares the second elements.

7) Compares lhs and rhs lexicographically by synthesized three-way comparison (see below), that is, compares the first elements and only if they are equivalent, compares the second elements.
The return type is the common comparison category type of the result type of synthesized three-way comparison of T1 and U1 and the one of T2 and U2.

The <, <=, >, >=, and != operators are synthesized from operator<=> and operator== respectively.

(since C++20)

Synthesized three-way comparison Given two object types T and U, a const T lvalue t as left hand operand, a const U lvalue u is right hand operand, synthesized three-way comparison is defined as: if std::three_way_comparable_with<T, U> is satisfied, equivalent to t <=> u; otherwise, if comparing a const T lvalue with a const U lvalue in both orders are well-formed and the result types satisfies boolean-testable, equivalent to t < u ? std::weak_ordering::less : u < t ? std::weak_ordering::greater : std::weak_ordering::equivalent otherwise, synthesized three-way comparison is not defined, which makes operator<=> not participate in overload resolution. The behavior of operator<=> is undefined if three_way_comparable_with or boolean-testable is satisfied but not modeled.

(since C++20)

Parameters

lhs, rhs

-

pairs to compare

Return value

1) true if both lhs.first == rhs.first and lhs.second == rhs.second, otherwise false

2) !(lhs == rhs)

3) If lhs.first < rhs.first, returns true. Otherwise, if rhs.first < lhs.first, returns false. Otherwise, if lhs.second < rhs.second, returns true. Otherwise, returns false.

4) !(rhs < lhs)

5) rhs < lhs

6) !(lhs < rhs)

7) synth_three_way(lhs.first, rhs.first) if it is not equal to ​0​, otherwise synth_three_way(lhs.second, rhs.second), where synth_three_way is an exposition-only function object performing synthesized three-way comparison.

Example

Because operator< is defined for pairs, containers of pairs can be sorted.

Run this code

#include <iostream>
#include <iomanip>
#include <utility>
#include <vector>
#include <algorithm>
#include <string>
 
int main()
{
    std::vector<std::pair<int, std::string>> v = {{2, "baz"},
                                                  {2, "bar"},
                                                  {1, "foo"}};
    std::sort(v.begin(), v.end());
 
    for (auto p: v)
        std::cout << "{" << p.first << ", " << std::quoted(p.second) << "}\n";
}

Output:

{1, "foo"}
{2, "bar"}
{2, "baz"}

Defect reports

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

DR	Applied to	Behavior as published	Correct behavior
LWG 296	C++98	the descriptions of operators other than == and < were missing	added
LWG 3865	C++98	comparison operators only accepted pairs of the same type	accept pairs of different types

See also

operator==operator!=operator<operator<=operator>operator>=operator<=> (removed in C++20)(removed in C++20)(removed in C++20)(removed in C++20)(removed in C++20)(C++20)

lexicographically compares the values in the tuple (function template)