Namespaces
Variants
Views
Actions

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

From cppreference.com
< cpp‎ | utility‎ | pair
 
 
Utilities library
General utilities
Relational operators (deprecated in C++20)
Integer comparison functions
(C++20)(C++20)(C++20)   
(C++20)
Swap and type operations
(C++14)
(C++11)

(C++11)
(C++11)
(C++17)
Common vocabulary types
(C++11)
(C++17)
(C++17)
(C++17)
(C++11)
(C++17)

Elementary string conversions
(C++17)
(C++17)

Stacktrace
 
std::pair
Member functions
pair::pair
Non-member functions
(until C++20)(until C++20)(until C++20)(until C++20)(until C++20)(C++20)
(C++11)
Deduction guides(C++17)
Helper classes
(C++11)
 
(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)
(4)
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)
(conditionally explicit)
(5)
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)
(6)
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;
(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.
(since C++11)
2) Initializes first with x and second with y.
(since C++11)
3) Initializes first with std::forward<U1>(x) and second with std::forward<U2>(y).
4) Initializes first with p.first and second with p.second.
(since C++11)
5) Initializes first with std::forward<U1>(p.first) and second with std::forward<U2>(p.second).
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 implicitly declared (until C++11)defaulted, and is constexpr if copying of both elements satisfies the requirements on constexpr functions (since C++11).
8) Move constructor is defaulted, and is constexpr if moving of both elements satisfies the requirements on constexpr functions.

Contents

[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

#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("(6) Piecewise constructed: ", p6);
}

Possible output:

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

[edit] 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

[edit] See also

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