W3cubDocs

std::pair<T1,T2>::pair

	(1)
pair();		(until C++11)
constexpr pair();		(since C++11) (conditionally explicit)
	(2)
pair( const T1& x, const T2& y );		(until C++11)
pair( const T1& x, const T2& y );		(since C++11) (until C++14) (conditionally explicit)
constexpr pair( const T1& x, const T2& y );		(since C++14) (conditionally explicit)
	(3)
template< class U1, class U2 > pair( U1&& x, U2&& y );		(since C++11) (until C++14) (conditionally explicit)
template< class U1, class U2 > constexpr pair( U1&& x, U2&& y );		(since C++14) (until C++23) (conditionally explicit)
template< class U1 = T1, class U2 = T2 > constexpr pair( U1&& x, U2&& y );		(since C++23) (conditionally explicit)
template< class U1, class U2 > constexpr pair( pair<U1, U2>& p );	(4)	(since C++23) (conditionally explicit)
	(5)
template< class U1, class U2 > pair( const pair<U1, U2>& p );		(until C++11)
template< class U1, class U2 > pair( const pair<U1, U2>& p );		(since C++11) (until C++14) (conditionally explicit)
template< class U1, class U2 > constexpr pair( const pair<U1, U2>& p );		(since C++14) (conditionally explicit)
	(6)
template< class U1, class U2 > pair( pair<U1, U2>&& p );		(since C++11) (until C++14) (conditionally explicit)
template< class U1, class U2 > constexpr pair( pair<U1, U2>&& p );		(since C++14) (conditionally explicit)
template< class U1, class U2 > constexpr pair( const pair<U1, U2>&& p );	(7)	(since C++23) (conditionally explicit)
	(8)
template< class... Args1, class... Args2 > pair( std::piecewise_construct_t, std::tuple<Args1...> first_args, std::tuple<Args2...> second_args );		(since C++11) (until C++20)
template< class... Args1, class... Args2 > constexpr pair( std::piecewise_construct_t, std::tuple<Args1...> first_args, std::tuple<Args2...> second_args );		(since C++20)
pair( const pair& p ) = default;	(9)
pair( pair&& p ) = default;	(10)	(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<T1> and std::is_default_constructible_v<T2> are both true.
This constructor is explicit if and only if either T1 or T2 is not implicitly default-constructible.

(since C++11)

2) Initializes first with x and second with y.

This constructor participates in overload resolution if and only if std::is_copy_constructible_v<T1> and std::is_copy_constructible_v<T2> are both true.
This constructor is explicit if and only if std::is_convertible_v<const T1&, T1> is false or std::is_convertible_v<const T2&, T2> is false.

(since C++11)

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

This constructor participates in overload resolution if and only if std::is_constructible_v<T1, U1> and std::is_constructible_v<T2, U2> are both true.
This constructor is explicit if and only if std::is_convertible_v<U1, T1> is false or std::is_convertible_v<U2, T2> is false.

This constructor is defined as deleted if the initialization of first or second would bind a reference to temporary object.

(since C++23)

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<T1, U1&> and std::is_constructible_v<T2, U2&> are both true.
This constructor is explicit if and only if std::is_convertible_v<U1&, T1> is false or std::is_convertible_v<U2&, T2> is false.
This constructor is defined as deleted if the initialization of first or second would bind a reference to temporary object.

5) Initializes first with p.first and second with p.second.

This constructor participates in overload resolution if and only if std::is_constructible_v<T1, const U1&> and std::is_constructible_v<T2, const U2&> are both true.
This constructor is explicit if and only if std::is_convertible_v<const U1&, T1> is false or std::is_convertible_v<const U2&, T2> is false.

(since C++11)

This constructor is defined as deleted if the initialization of first or second would bind a reference to temporary object.

(since C++23)

6) 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<T1, U1> and std::is_constructible_v<T2, U2> are both true.
This constructor is explicit if and only if std::is_convertible_v<U1, T1> is false or std::is_convertible_v<U2, T2> is false.

This constructor is defined as deleted if the initialization of first or second would bind a reference to temporary object.

(since C++23)

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

This constructor participates in overload resolution if and only if std::is_constructible_v<T1, U1> and std::is_constructible_v<T2, U2> are both true.
This constructor is explicit if and only if std::is_convertible_v<const U1, T1> is false or std::is_convertible_v<const U2, T2> is false.
This constructor is defined as deleted if the initialization of first or second would bind a reference to temporary object.

8) 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. The program is ill-formed if first or second is a reference and bound to a temporary object.

9) Copy constructor is implicitly declared (until C++11)defaulted, and is constexpr if copying of both elements satisfies the requirements on constexpr functions (since C++11).

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

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

Exceptions

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

Example

#include <utility>
#include <string>
#include <complex>
#include <tuple>
#include <iostream>
 
int main()
{
    auto print = [](auto rem, auto const& pair) {
        std::cout << rem << "(" << pair.first << ", " << pair.second << ")\n";
    };
 
    std::pair<int, float> p1;
    print("(1) Value-initialized: ", p1);
 
    std::pair<int, double> p2{42, 3.1415};
    print("(2) Initialized with two values: ", p2);
 
    std::pair<char, int> p4{p2};
    print("(4) Implicitly converted: ", p4);
 
    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')};
    print("(8) Piecewise constructed: ", p6);
}

Possible output:

(1) Value-initialized: (0, 0)
(2) Initialized with two values: (42, 3.1415)
(4) Implicitly converted: (*, 3)
(8) Piecewise constructed: ((0.123,7.7), aaaaaaaaaa)

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR	Applied to	Behavior as published	Correct behavior
N4387	C++11	some constructors were implicit-only, preventing some uses	constructors made conditionally-explicit
LWG 2510	C++11	default constructor was implicit	made conditionally-explicit

make_pair	creates a `pair` object of type, defined by the argument types (function template)
(constructor) (C++11)	constructs a new `tuple` (public member function of `std::tuple<Types...>`)

std::pair<T1,T2>::pair

Parameters

Exceptions

Example

Defect reports

See also