(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.
first
and second
.
| (since C++11) |
first
with x
and second
with y
.
| (since C++11) |
first
with std::forward<U1>(x)
and second
with std::forward<U2>(y)
. std::is_constructible_v<T1, U1>
and std::is_constructible_v<T2, U2>
are both true
. explicit
if and only if std::is_convertible_v<U1, T1>
is false
or std::is_convertible_v<U2, T2>
is false
.
| (since C++23) |
first
with p.first
and second
with p.second
. std::is_constructible_v<T1, U1&>
and std::is_constructible_v<T2, U2&>
are both true
. explicit
if and only if std::is_convertible_v<U1&, T1>
is false
or std::is_convertible_v<U2&, T2>
is false
. first
or second
would bind a reference to temporary object.first
with p.first
and second
with p.second
.
| (since C++11) |
| (since C++23) |
first
with std::forward<U1>(p.first)
and second
with std::forward<U2>(p.second)
. std::is_constructible_v<T1, U1>
and std::is_constructible_v<T2, U2>
are both true
. explicit
if and only if std::is_convertible_v<U1, T1>
is false
or std::is_convertible_v<U2, T2>
is false
.
| (since C++23) |
first
with std::forward<const U1>(p.first)
and second
with std::forward<const U2>(p.second)
. std::is_constructible_v<T1, U1>
and std::is_constructible_v<T2, U2>
are both true
. explicit
if and only if std::is_convertible_v<const U1, T1>
is false
or std::is_convertible_v<const U2, T2>
is false
. first
or second
would bind a reference to temporary object.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.constexpr
if copying of both elements satisfies the requirements on constexpr functions (since C++11).constexpr
if moving of both elements satisfies the requirements on constexpr functions.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 |
Does not throw exceptions unless one of the specified operations (e.g. constructor of an element) throws.
#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)
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 |
creates a pair object of type, defined by the argument types (function template) |
|
(C++11) | constructs a new tuple (public member function of std::tuple<Types...> ) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/utility/pair/pair