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

 

C++

Compiler support

Freestanding and hosted

Language

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 Program utilities Coroutine support (C++20) Variadic functions is_constant_evaluated (C++20) launder (C++17) 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 > bool operator==( const std::pair<T1,T2>& lhs, const std::pair<T1,T2>& rhs );			(until C++14)
template< class T1, class T2 > constexpr bool operator==( const std::pair<T1,T2>& lhs,                            const std::pair<T1,T2>& rhs );			(since C++14)
		(2)
template< class T1, class T2 > bool operator!=( const std::pair<T1,T2>& lhs, const std::pair<T1,T2>& rhs );				(until C++14)
template< class T1, class T2 > constexpr bool operator!=( const std::pair<T1,T2>& lhs,                            const std::pair<T1,T2>& rhs );				(since C++14) (until C++20)
			(3)
template< class T1, class T2 > bool operator<( const std::pair<T1,T2>& lhs, const std::pair<T1,T2>& rhs );					(until C++14)
template< class T1, class T2 > constexpr bool operator<( const std::pair<T1,T2>& lhs,                           const std::pair<T1,T2>& rhs );					(since C++14) (until C++20)
				(4)
template< class T1, class T2 > bool operator<=( const std::pair<T1,T2>& lhs, const std::pair<T1,T2>& rhs );						(until C++14)
template< class T1, class T2 > constexpr bool operator<=( const std::pair<T1,T2>& lhs,                            const std::pair<T1,T2>& rhs );						(since C++14) (until C++20)
					(5)
template< class T1, class T2 > bool operator>( const std::pair<T1,T2>& lhs, const std::pair<T1,T2>& rhs );							(until C++14)
template< class T1, class T2 > constexpr bool operator>( const std::pair<T1,T2>& lhs,                           const std::pair<T1,T2>& rhs );							(since C++14) (until C++20)
						(6)
template< class T1, class T2 > bool operator>=( const std::pair<T1,T2>& lhs, const std::pair<T1,T2>& rhs );								(until C++14)
template< class T1, class T2 > constexpr bool operator>=( const std::pair<T1,T2>& lhs,                            const std::pair<T1,T2>& rhs );								(since C++14) (until C++20)
template< class T1, class T2 > constexpr /* see below */ operator<=>( const std::pair<T1,T2>& lhs,                                        const std::pair<T1,T2>& 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 on T1 and the one of T2.

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

(since C++20)

Synthesized three-way comparison Given an object type T, two const T lvalues lhs and rhs as left hand operand and right hand operand respectively, synthesized three-way comparison is defined as: if std::three_way_comparable_with<T, T> is satisfied, equivalent to lhs <=> rhs; otherwise, if comparing two const T lvalues by operator< is well-formed and the result type satisfies boolean-testable, equivalent to lhs < rhs ? std::weak_ordering::less : rhs < lhs ? 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"}

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)