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) |
lhs.first
with rhs.first
and lhs.second
with rhs.second
.lhs
and rhs
lexicographically by operator<
, that is, compares the first elements and only if they are equivalent, compares the second elements.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.T1
and the one of T2
. The | (since C++20) |
Synthesized three-way comparisonGiven an object type
lhs < rhs ? std::weak_ordering::less : rhs < lhs ? std::weak_ordering::greater : std::weak_ordering::equivalent
The behavior of | (since C++20) |
lhs, rhs | - | pairs to compare |
true
if both lhs.first == rhs.first
and lhs.second == rhs.second
, otherwise false
!(lhs == rhs)
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
.!(rhs < lhs)
rhs < lhs
!(lhs < rhs)
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.Because operator< is defined for pairs, containers of pairs can be sorted.
#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"}
(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) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/utility/pair/operator_cmp