W3cubDocs

/C++

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

Defined in header `<utility>`
template< class T1, class T2 > bool operator==( const pair<T1,T2>& lhs, const pair<T1,T2>& rhs );	(1)	(until C++14)
template< class T1, class T2 > constexpr bool operator==( const pair<T1,T2>& lhs, const pair<T1,T2>& rhs );	(1)	(since C++14)
template< class T1, class T2 > bool operator!=( const pair<T1,T2>& lhs, const pair<T1,T2>& rhs );	(2)	(until C++14)
template< class T1, class T2 > constexpr bool operator!=( const pair<T1,T2>& lhs, const pair<T1,T2>& rhs );	(2)	(since C++14)
template< class T1, class T2 > bool operator<( const pair<T1,T2>& lhs, const pair<T1,T2>& rhs );	(3)	(until C++14)
template< class T1, class T2 > constexpr bool operator<( const pair<T1,T2>& lhs, const pair<T1,T2>& rhs );	(3)	(since C++14)
template< class T1, class T2 > bool operator<=( const pair<T1,T2>& lhs, const pair<T1,T2>& rhs );	(4)	(until C++14)
template< class T1, class T2 > constexpr bool operator<=( const pair<T1,T2>& lhs, const pair<T1,T2>& rhs );	(4)	(since C++14)
template< class T1, class T2 > bool operator>( const pair<T1,T2>& lhs, const pair<T1,T2>& rhs );	(5)	(until C++14)
template< class T1, class T2 > constexpr bool operator>( const pair<T1,T2>& lhs, const pair<T1,T2>& rhs );	(5)	(since C++14)
template< class T1, class T2 > bool operator>=( const pair<T1,T2>& lhs, const pair<T1,T2>& rhs );	(6)	(until C++14)
template< class T1, class T2 > constexpr bool operator>=( const pair<T1,T2>& lhs, const pair<T1,T2>& rhs );	(6)	(since C++14)

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, that is, compares the first elements and only if they are equivalent, compares the second elements.

Parameters

lhs, rhs

pairs to compare

Return value

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

2) true if either lhs.first != rhs.first or lhs.second != rhs.second, otherwise false.

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).

Example

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

#include <iostream>
#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 << "," << p.second << ")\n";
    }
}

Output:

(1,foo)
(2,bar)
(2,baz)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
http://en.cppreference.com/w/cpp/utility/pair/operator_cmp