std::pair::pair

 

C++

Language

Standard Library Headers

Freestanding and hosted implementations

Named requirements

Language support library

Concepts library (C++20)

Diagnostics library

Utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

 

Utilities library

Type support (basic types, RTTI, type traits)
Dynamic memory management
Error handling
Program utilities
Variadic functions
Library feature-test macros
Date and time
Function objects
initializer_list (C++11)
bitset
hash (C++11)
integer_sequence (C++14)
Relational operators (deprecated in C++20)
rel_ops::operator!=rel_ops::operator>rel_ops::operator<=rel_ops::operator>=
Comparisons (C++20)
strong_order weak_order partial_order strong_equal weak_equal	strong_ordering weak_ordering partial_ordering strong_equality weak_equality	is_eqis_neqis_ltis_lteqis_gtis_gteq
common_comparison_category
Common vocabulary types
pair tuple (C++11) apply (C++17) make_from_tuple (C++17)	optional (C++17) any (C++17) variant (C++17)
Swap, forward and move
swap
exchange (C++14)
forward (C++11)
move (C++11)
move_if_noexcept (C++11)
Elementary string conversions
to_chars (C++17)
from_chars (C++17)
chars_format (C++17)
Type operations
declval (C++11)
as_const (C++17)
launder (C++17)

 

std::pair

Member functions

pair::pair

pair::operator=

pair::swap

Non-member functions

make_pair

operator==operator!=operator<operator<=operator>operator>=

std::swap

get (C++11)

Deduction guides(C++17)

Helper classes

tuple_size (C++11)

tuple_element (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) (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) (until C++14) (conditionally explicit)
template< class U1, class U2 > constexpr pair( const pair<U1, U2>& p );						(since C++14) (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.

This constructor participates in overload resolution if and only if std::is_default_constructible_v<first_type> and std::is_default_constructible_v<second_type> are both true. This constructor is explicit if and only if either first_type or second_type 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<first_type> and std::is_copy_constructible_v<second_type> are both true. This constructor is explicit if and only if std::is_convertible_v<const first_type&, first_type> is false or std::is_convertible_v<const second_type&, second_type> 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<first_type, U1&&> and std::is_constructible_v<second_type, U2&&> are both true.
• This constructor is explicit if and only if std::is_convertible_v<U1&&, first_type> is false or std::is_convertible_v<U2&&, second_type> is false.

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<first_type, const U1&> and std::is_constructible_v<second_type, const U2&> are both true. This constructor is explicit if and only if std::is_convertible_v<const U1&, first_type> is false or std::is_convertible_v<const U2&, second_type> is false.

(since C++11)

5) 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<first_type, U1&&> and std::is_constructible_v<second_type, U2&&> are both true.
• This constructor is explicit if and only if std::is_convertible_v<U1&&, first_type> is false or std::is_convertible_v<U2&&, second_type> is false.

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 defaulted, and is constexpr if copying of both elements satisfies the requirements on constexpr functions.

8) 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.

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

Example

Run this code

#include <utility>
#include <string>
#include <complex>
#include <tuple>
#include <iostream>
 
int main()
{
    std::pair<int, float> p1;
    std::cout << "Value-initialized: "
              << p1.first << ", " << p1.second << '\n';
 
    std::pair<int, double> p2(42, 0.123);
    std::cout << "Initialized with two values: "
              << p2.first << ", " << p2.second << '\n';
 
    std::pair<char, int> p4(p2);
    std::cout << "Implicitly converted: "
              << p4.first << ", " << p4.second << '\n';
 
    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'));
    std::cout << "Piecewise constructed: "
              << p6.first << ", " << p6.second << '\n';
}

Output:

Value-initialized: 0, 0
Initialized with two values: 42, 0.123
Implicitly converted: *, 0
Piecewise constructed: (0.123,7.7), aaaaaaaaaa

See also

make_pair

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