## pair

    Utility Class

- Summary
- Data Type and Member Function Indexes
- Synopsis
- Description
- Interface
- Types
- Constructors
- Destructors
- Non-member Operators
- Non-member Functions

### Summary

A template for heterogeneous pairs of values.

### Data Type and Member Function Indexes
(exclusive of constructors and destructors)

Data Types
first_type second_type

Member Functions
make_pair() operator!=() operator>() operator>=() operator<() operator<=() | operator==()

### Synopsis

    #include <utility>
    template <class T1, class T2>
    struct pair ;

### Description

The pair class is a template for encapsulating pairs of values that may be of different types.

### Interface

    template <class T1, class T2>
     struct pair {
            typedef T1 first_type;
            typedef T2 second_type;
            T1 first;
            T2 second;
            pair();
            pair (const T1&, const T2&);
            template <class V, class U>
            pair (const pair <V, U>& p);
            ~pair();
    };

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

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

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

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

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

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

    template <class T1, class T2>
     pair<T1,T2> make_pair (const T1&, const T2&);

### Types

    first_type

Type of the first element in a pair.

    second_type

Type of the second element in a pair.

### Constructors

    pair ();

Default constructor. Initializes `first` and `second` using their default constructors.

    pair (const T1& x, const T2& y);

Creates a pair of types `T1` and `T2`, making the necessary conversions in `x` and `y`.

    template <class V, class U>
    pair (const pair <V, U>& p);

Copies `first` and `second` from the corresponding elements of `p`.

### Destructors

    ~pair ();

### Non-member Operators

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

Returns `true` if `(x.first == y.first && x.second == y.second`) is `true`. Otherwise it returns `false`.

    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 `true` if `(x.first < y.first || (!(y.first < x.first) && x.second < y.second))` is `true`. Otherwise it returns `false`.

    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 `!(y < x)`.

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

Returns `!(x < y)`.

### Non-member Functions

    template <class T1, class T2>
    pair<T1,T2>
    make_pair(x,y);

`make_pair(x,y)` creates a pair by deducing and returning the types of `x` and `y`.

Copyright (c) 1998, Rogue Wave Software, Inc.
Send mail to report errors or comment on the documentation.
OEM Release, June 1998