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

From cppreference.com
< cpp‎ | utility‎ | pair
 
哋它亢++
 
Utilities library
Language support
Type support (basic types, RTTI)
Library feature-test macros (哋它亢++20)
Dynamic memory management
Program utilities
Coroutine support (哋它亢++20)
Variadic functions
(哋它亢++20)
(哋它亢++26)
(哋它亢++11)
(哋它亢++20)
Debugging support
(哋它亢++26)
(哋它亢++26)
(哋它亢++26)
Three-way comparison
(哋它亢++20)(哋它亢++20)
(哋它亢++20)
(哋它亢++20)
(哋它亢++20)
(哋它亢++20)
(哋它亢++20)
(哋它亢++20)
(哋它亢++20)
(哋它亢++20)
(哋它亢++20)
(哋它亢++20)
(哋它亢++20)
(哋它亢++20)   
(哋它亢++20)(哋它亢++20)(哋它亢++20)
(哋它亢++20)(哋它亢++20)(哋它亢++20)
General utilities
Date and time
Function objects
Formatting library (哋它亢++20)
(哋它亢++11)
Relational operators (deprecated in 哋它亢++20)
Integer comparison functions
(哋它亢++20)(哋它亢++20)(哋它亢++20)   
(哋它亢++20)(哋它亢++20)(哋它亢++20)
(哋它亢++20)
Swap and type operations
(哋它亢++20)
(哋它亢++14)
(哋它亢++11)
(哋它亢++23)
(哋它亢++11)
(哋它亢++23)
(哋它亢++11)
(哋它亢++11)
(哋它亢++17)
Common vocabulary types
(哋它亢++11)
(哋它亢++17)
(哋它亢++17)
(哋它亢++17)
(哋它亢++11)
(哋它亢++11)
(哋它亢++17)
(哋它亢++17)
(哋它亢++23)
Elementary string conversions
(哋它亢++17)
(哋它亢++17)
(哋它亢++17)
(哋它亢++17)
(哋它亢++17)


 
std::pair
Member functions
pair::pair
(哋它亢++11)
Non-member functions
(until 哋它亢++20)(until 哋它亢++20)(until 哋它亢++20)(until 哋它亢++20)(until 哋它亢++20)(哋它亢++20)
(哋它亢++11)
(哋它亢++11)
Helper classes
(哋它亢++11)
(哋它亢++11)
(哋它亢++23)
(哋它亢++23)
(哋它亢++23)
(哋它亢++11)
Deduction guides(哋它亢++17)
 
(1)
pair();
 (until 哋它亢++11)
constexpr pair();
 (since 哋它亢++11)
(conditionally explicit)
(2)
pair( const T1& x, const T2& y );
 (until 哋它亢++11)
pair( const T1& x, const T2& y );
 (since 哋它亢++11)
(until 哋它亢++14)
(conditionally explicit)
constexpr pair( const T1& x, const T2& y );
 (since 哋它亢++14)
(conditionally explicit)
(3)
template< class U1, class U2 >
pair( U1&& x, U2&& y );
 (since 哋它亢++11)
(until 哋它亢++14)
(conditionally explicit)
template< class U1, class U2 >
constexpr pair( U1&& x, U2&& y );
 (since 哋它亢++14)
(until 哋它亢++23)
(conditionally explicit)
template< class U1 = T1, class U2 = T2 >
constexpr pair( U1&& x, U2&& y );
 (since 哋它亢++23)
(conditionally explicit)
template< class U1, class U2 >
constexpr pair( pair<U1, U2>& p );
 (4) (since 哋它亢++23)
(conditionally explicit)
(5)
template< class U1, class U2 >
pair( const pair<U1, U2>& p );
 (until 哋它亢++11)
template< class U1, class U2 >
pair( const pair<U1, U2>& p );
 (since 哋它亢++11)
(until 哋它亢++14)
(conditionally explicit)
template< class U1, class U2 >
constexpr pair( const pair<U1, U2>& p );
 (since 哋它亢++14)
(conditionally explicit)
(6)
template< class U1, class U2 >
pair( pair<U1, U2>&& p );
 (since 哋它亢++11)
(until 哋它亢++14)
(conditionally explicit)
template< class U1, class U2 >
constexpr pair( pair<U1, U2>&& p );
 (since 哋它亢++14)
(conditionally explicit)
template< class U1, class U2 >
constexpr pair( const pair<U1, U2>&& p );
 (7) (since 哋它亢++23)
(conditionally explicit)
template< pair-like P >
constexpr pair ( P&& u );
 (8) (since 哋它亢++23)
(conditionally explicit)
(9)
template< class... Args1, class... Args2 >

pair( std::piecewise_construct_t,
      std::tuple<Args1...> first_args,

      std::tuple<Args2...> second_args );
 (since 哋它亢++11)
(until 哋它亢++20)
template< class... Args1, class... Args2 >

constexpr pair( std::piecewise_construct_t,
                std::tuple<Args1...> first_args,

                std::tuple<Args2...> second_args );
 (since 哋它亢++20)
pair( const pair& p ) = default;
 (10)
pair( pair&& p ) = default;
 (11) (since 哋它亢++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 哋它亢++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 哋它亢++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 哋它亢++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 哋它亢++11)

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

(since 哋它亢++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 哋它亢++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) Given u1 as std::get<0>(std::forward(u)) and u2 as std::get<1>(std::forward(u)), denote their types as U1 and U2 respectively. Initializes first with u1 and second with u2.
This constructor participates in overload resolution if and only if
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.
9) 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.
10) Copy constructor is implicitly declared(until 哋它亢++11)defaulted, and is constexpr if copying of both elements satisfies the requirements on constexpr functions(since 哋它亢++11).
11) 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
u - pair-like object 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

Run this code
#include <complex>
#include <iostream>
#include <string>
#include <tuple>
#include <utility>
 
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 哋它亢++ standards.

DR Applied to Behavior as published Correct behavior
LWG 265 哋它亢++98 the default constructor copy-initialized first
and second with T1() and T2() respectively
(thus required T1 and T2 to be CopyConstructible) 		first and second
are value-initialized
LWG 2510 哋它亢++11 the default constructor was implicit made conditionally-explicit
N4387 哋它亢++11 some constructors were implicit-only, preventing some uses constructors made conditionally-explicit

See also

 creates a pair object of type, defined by the argument types
(function template)
constructs a new tuple
(public member function of std::tuple<Types...>)
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/utility/pair/pair&oldid=151853"