std::pair::pair(3)

NAME
std::pair::pair - std::pair::pair

Synopsis
pair(); (until C++11)
                        (since C++11) constexpr pair(); (conditionally
                        explicit) pair( const T1& x, const (until C++11) T2& y );
                        (since C++11) pair( const T1& x, const (until C++14) T2& y ); (conditionally
                        explicit) constexpr pair( const T1& (since C++14) x, const T2& y ); (conditionally
                        explicit) template< class U1, class (since C++11) U2 > (until C++14) pair( U1&& x, U2&& y ); (conditionally
                        explicit) template< class U1, class (since C++14) U2 > (until C++23) constexpr pair( U1&& x, (conditionally U2&& y ); explicit) template< class U1 = T1, (since C++23) class U2 = T2 > (conditionally constexpr pair( U1&& x, explicit) U2&& y ); template< class U1, class (since C++23) U2 > (4) (conditionally constexpr pair( pair<U1, explicit) U2>& p ); template< class U1, class U2 > (until C++11) pair( const pair<U1, U2>& p ); template< class U1, class (since C++11) U2 > (until C++14) pair( const pair<U1, U2>& p (conditionally ); explicit) template< class U1, class (since C++14) U2 > (1) (conditionally constexpr pair( const explicit) pair<U1, U2>& p ); (2) template< class U1, class (since C++11) U2 > (until C++14) pair( pair<U1, U2>&& p ); (conditionally
                        (3) explicit) template< class U1, class (since C++14) U2 > (conditionally constexpr pair( pair<U1, explicit) U2>&& p ); template< class U1, class (since C++23) U2 > (7) (conditionally constexpr pair( const explicit) pair<U1, U2>&& p ); (5) template< class... Args1, class... Args2 > pair( (since std::piecewise_construct_t, C++11) std::tuple<Args1...> (6) (until first_args, C++20) std::tuple<Args2...> second_args ); template< class... Args1, class... Args2 > (8) constexpr pair( std::piecewise_construct_t, (since std::tuple<Args1...> C++20) first_args, std::tuple<Args2...> second_args ); pair( const pair& p ) = (9) default; 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. (since C++11)
     * This constructor is explicit if and only if either T1 or T2 is not
       implicitly default-constructible.
   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. (since C++11)
     * 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.
   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 (since C++23)
       first or second would bind a reference to temporary object.
   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. (since C++11)
     * 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 (since C++23)
       first or second would bind a reference to temporary object.
   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 (since C++23)
       first or second would bind a reference to temporary object.
   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
// Run this code
 #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 constructors made
                       implicit-only, preventing some uses conditionally-explicit
   LWG 2510 C++11 default constructor was implicit made conditionally-explicit

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