20 General utilities library [utilities]

20.3 Pairs [pairs]

20.3.3 Specialized algorithms [pairs.spec]

``` template <class T1, class T2> bool operator==(const pair<T1, T2>& x, const pair<T1, T2>& y); ```

Returns: x.first == y.first && x.second == y.second.

``` template <class T1, class T2> bool operator<(const pair<T1, T2>& x, const pair<T1, T2>& y); ```

Returns: x.first < y.first || (!(y.first < x.first) && x.second < y.second).

``` template <class T1, class T2> bool operator!=(const pair<T1, T2>& x, const pair<T1, T2>& y); ```

Returns: !(x == y)

``` template <class T1, class T2> bool operator>(const pair<T1, T2>& x, const pair<T1, T2>& y); ```

Returns: y < x

``` template <class T1, class T2> bool operator>=(const pair<T1, T2>& x, const pair<T1, T2>& y); ```

Returns: !(x < y)

``` template <class T1, class T2> bool operator<=(const pair<T1, T2>& x, const pair<T1, T2>& y); ```

Returns: !(y < x)

``` template<class T1, class T2> void swap(pair<T1, T2>& x, pair<T1, T2>& y) noexcept(noexcept(x.swap(y))); ```

Effects: x.swap(y)

``` template <class T1, class T2> pair<V1, V2> make_pair(T1&& x, T2&& y); ```

Returns: pair<V1, V2>(std::forward<T1>(x), std::forward<T2>(y));

where V1 and V2 are determined as follows: Let Ui be decay<Ti>::type for each Ti. Then each Vi is X& if Ui equals reference_wrapper<X>, otherwise Vi is Ui.

Example: In place of:

```  return pair<int, double>(5, 3.1415926);   // explicit types
```

a C++ program may contain:

```  return make_pair(5, 3.1415926);           // types are deduced
```

— end example ]