##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# std::pair::pair

From cppreference.com
< cpp‎ | utility‎ | pair

| (1) |
pair(); |  | (until C++11)
constexpr pair(); |  | (since C++11) (until C++17)
/*EXPLICIT*/ constexpr pair(); |  | (since C++17)
| (2) |
pair( const T1& x, const T2& y ); |  | (until C++14)
constexpr pair( const T1& x, const T2& y ); |  | (since C++14) (until C++17)
/*EXPLICIT*/ constexpr pair( const T1& x, const T2& y ); |  | (since C++17)
| (3) |
template< class U1, class U2 > pair( U1&& x, U2&& y ); |  | (since C++11) (until C++14)
template< class U1, class U2 > constexpr pair( U1&& x, U2&& y ); |  | (since C++14) (until C++17)
template< class U1, class U2 > /*EXPLICIT*/ constexpr pair( U1&& x, U2&& y ); |  | (since C++17)
| (4) |
template< class U1, class U2 > pair( const pair<U1, U2>& p ); |  | (until C++14)
template< class U1, class U2 > constexpr pair( const pair<U1, U2>& p ); |  | (since C++14) (until C++17)
template< class U1, class U2 > /*EXPLICIT*/ constexpr pair( const pair<U1, U2>& p ); |  | (since C++17)
| (5) |
template< class U1, class U2 > pair( pair<U1, U2>&& p ); |  | (since C++11) (until C++14)
template< class U1, class U2 > constexpr pair( pair<U1, U2>&& p ); |  | (since C++14) (until C++17)
template< class U1, class U2 > /*EXPLICIT*/ constexpr pair( pair<U1, U2>&& p ); |  | (since C++17)
template< class... Args1, class... Args2 > pair( std::piecewise_construct_t, std::tuple<Args1...> first_args, std::tuple<Args2...> second_args ); | (6) | (since C++11)
pair( const pair& p ) = default; | (7) |
pair( pair&& p ) = default; | (8) | (since C++11)

Constructs a new pair.

1) Default constructor. Value-initializes both elements of the pair, `first` and `second`.

This constructor participates in overload resolution if and only if std::is_default_constructible_v<first_type> and std::is_default_constructible_v<second_type> are both true. This constructor is explicit if and only if either `first_type` or `second_type` is not implicitly default-constructible. | (since C++17)

2) Initializes `first` with `x` and `second` with `y`.

This constructor participates in overload resolution if and only if std::is_copy_constructible_v<first_type> and std::is_copy_constructible_v<second_type> are both true. This constructor is explicit if and only if std::is_convertible_v<const first_type&, first_type> is false or std::is_convertible_v<const second_type&, second_type> is false. | (since C++17)

3) Initializes `first` with std::forward<U1>(x) and `second` with std::forward<U2>(y).

This constructor participates in overload resolution only if `U1` is implicitly convertible to `first_type` and `U2` is implicitly convertible to `second_type`. | (until C++17)
This constructor participates in overload resolution if and only if std::is_constructible_v<first_type, U1&&> and std::is_constructible_v<second_type, U2&&> are both true. This constructor is explicit if and only if std::is_convertible_v<U1&&, first_type> is false or std::is_convertible_v<U2&&, second_type> is false. | (since C++17)

4) Initializes `first` with `p.first` and `second` with `p.second`.

This constructor participates in overload resolution if and only if std::is_constructible_v<first_type, const U1&> and std::is_constructible_v<second_type, const U2&> are both true. This constructor is explicit if and only if std::is_convertible_v<const U1&, first_type> is false or std::is_convertible_v<const U2&, second_type> is false. | (since C++17)

5) Initializes `first` with std::forward<U1>(p.first) and `second` with std::forward<U2>(p.second).

This constructor participates in overload resolution if and only if std::is_constructible_v<first_type, U1&&> and std::is_constructible_v<second_type, U2&&> are both true. This constructor is explicit if and only if std::is_convertible_v<U1&&, first_type> is false or std::is_convertible_v<U2&&, second_type> is false. | (since C++17)

6) Forwards the elements of `first_args` to the constructor of `first` and forwards the elements of `second_args` to the constructor of `second`. This is the only non-default constructor that can be used to create a pair of non-copyable non-movable types.

7) Copy constructor is defaulted, and is constexpr if copying of both elements satisfies the requirements on constexpr functions.

8) Move constructor is defaulted, and is constexpr if moving of both elements satisfies the requirements on constexpr functions.

### [edit] Parameters

x | - | value to initialize the first element of this pair
y | - | value to initialize the second element of this pair
p | - | pair of values used to initialize both elements of this pair
first_args | - | tuple of constructor arguments to initialize the first element of this pair
second_args | - | tuple of constructor arguments to initialize the second element of this pair

### [edit] Exceptions

Does not throw exceptions unless one of the specified operations (e.g. constructor of an element) throws.

### [edit] Example

Run this code

    #include <utility>
    #include <string>
    #include <complex>
    #include <tuple>
    #include <iostream>

    int main()
    {
        std::pair<int, float> p1;
        std::cout << "Value-initialized: "
                  << p1.first << ", " << p1.second << '\n';

        std::pair<int, double> p2(42, 0.123);
        std::cout << "Initialized with two values: "
                  << p2.first << ", " << p2.second << '\n';

        std::pair<char, int> p4(p2);
        std::cout << "Implicitly converted: "
                  << p4.first << ", " << p4.second << '\n';

        std::pair<std::complex<double>, std::string> p6(
                        std::piecewise_construct,
                        std::forward_as_tuple(0.123, 7.7),
                        std::forward_as_tuple(10, 'a'));
        std::cout << "Piecewise constructed: "
                  << p6.first << ", " << p6.second << '\n';
    }

Output:

    Value-initialized: 0, 0
    Initialized with two values: 42, 0.123
    Implicitly converted: *, 0
    Piecewise constructed: (0.123,7.7), aaaaaaaaaa

### [edit] See also

make_pair | creates a `pair` object of type, defined by the argument types (function template) [edit]

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/utility/pair/pair&oldid=88366"