Difference between revisions of "cpp/utility/pair"

Latest revision as of 04:28, 24 July 2024

Defined in header `<utility>`
template< class T1, class T2 > struct pair;

std::pair is a class template that provides a way to store two heterogeneous objects as a single unit. A pair is a specific case of a std::tuple with two elements.

If neither T1 nor T2 is a possibly cv-qualified class type with non-trivial destructor, or array thereof, the destructor of pair is trivial.

make_pair	creates a `pair` object of type, determined by the argument types (function template) [edit]
operator==operator!=operator<operator<=operator>operator>=operator<=> (removed in C++20)(removed in C++20)(removed in C++20)(removed in C++20)(removed in C++20)(C++20)	lexicographically compares the values in the `pair` (function template) [edit]
std::swap(std::pair) (C++11)	specializes the std::swap algorithm (function template) [edit]
get(std::pair) (C++11)	accesses an element of a `pair` (function template) [edit]

[edit] Helper classes

std::tuple_size<std::pair> (C++11)	obtains the size of a `pair` (class template specialization) [edit]
std::tuple_element<std::pair> (C++11)	obtains the type of the elements of `pair` (class template specialization) [edit]
std::basic_common_reference<std::pair> (C++23)	determines the common reference type of two `pair`s (class template specialization) [edit]
std::common_type<std::pair> (C++23)	determines the common type of two `pair`s (class template specialization) [edit]
std::formatter<std::pair> (C++23)	formatting support for `pair` (class template specialization) [edit]

[edit] Helper specializations

template< class T, class U > constexpr bool enable_nonlocking_formatter_optimization<std::pair<T, U>> = enable_nonlocking_formatter_optimization<T> && enable_nonlocking_formatter_optimization<U>;		(since C++23)

This specialization of std::enable_nonlocking_formatter_optimization enables efficient implementation of std::print and std::println for printing a pair object when both T and U enable it.

[edit] Deduction guides(since C++17)

[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
LWG 2796	C++98	triviality of the destructor of `pair` was unspecified	specified

[edit] See also

tuple (C++11)	implements fixed size container, which holds elements of possibly different types (class template) [edit]
tie (C++11)	creates a tuple of lvalue references or unpacks a tuple into individual objects (function template) [edit]

@@ Line 1: / Line 1: @@
 {{cpp/title|pair}}
-{{cpp/utility/pair/sidebar}}
+{{cpp/utility/pair/navbar}}
-{{ddcl | header=utility |
+{{ddcl|header=utility|
 template<
      class T1,
@@ Line 8: / Line 8: @@
 }}
-<code>std::pair</code> is a struct template that provides a way to store two heterogeneous objects as a single unit.
+{{tt|std::pair}} is a class template that provides a way to store two heterogeneous objects as a single unit. A pair is a specific case of a {{lc|std::tuple}} with two elements.
+If neither {{tt|T1}} nor {{tt|T2}} is a possibly cv-qualified class type with non-trivial destructor, or array thereof, the destructor of {{tt|pair}} is trivial.
+===Template parameters===
+{{par begin}}
+{{par|T1, T2|the types of the elements that the pair stores.}}
+{{par end}}
 ===Member types===
-{{tdcl list begin}}
+{{dsc begin}}
-{{tdcl list hitem | Member type | Definition}}
+{{dsc hitem|Member type|Definition}}
-{{tdcl list item | <code>first_type</code> | <code>T1</code>}}
+{{dsc|{{tt|first_type}}|{{tt|T1}}}}
-{{tdcl list item | <code>second_type</code> | <code>T2</code>}}
+{{dsc|{{tt|second_type}}|{{tt|T2}}}}
-{{tdcl list end}}
+{{dsc end}}
 ===Member objects===
-{{tdcl list begin}}
+{{dsc begin}}
-{{tdcl list hitem | Member name | Type}}
+{{dsc hitem|Member name|Type}}
-{{tdcl list item | <code>first</code> | <code>T1</code>}}
+{{dsc|{{tt|first}}|{{tt|T1}}}}
-{{tdcl list item | <code>second</code> | <code>T2</code>}}
+{{dsc|{{tt|second}}|{{tt|T2}}}}
-{{tdcl list end}}
+{{dsc end}}
 ===Member functions===
-{{dcl list begin}}
+{{dsc begin}}
-{{dcl list mem ctor | cpp/utility/pair/pair | constructs new pair}}
+{{dsc inc|cpp/utility/pair/dsc constructor}}
-{{dcl list mem fun | cpp/utility/pair/operator{{=}} | assigns the contents}}
+{{dsc inc|cpp/utility/pair/dsc operator{{=}}}}
-{{dcl list mem fun | cpp/utility/pair/swap | swaps the contents | notes={{mark c++11}} }}
+{{dsc inc|cpp/utility/pair/dsc swap}}
-{{dcl list end}}
+{{dsc end}}
 ===Non-member functions===
-{{dcl list begin}}
+{{dsc begin}}
-{{dcl list template | cpp/utility/pair/dcl list make_pair}}
+{{dsc inc|cpp/utility/pair/dsc make_pair}}
-{{dcl list template | cpp/utility/pair/dcl list operator_comp}}
+{{dsc inc|cpp/utility/pair/dsc operator_cmp}}
-{{dcl list template | cpp/utility/pair/dcl list swap2}}
+{{dsc inc|cpp/utility/pair/dsc swap2}}
-{{dcl list template | cpp/utility/pair/dcl list get}}
+{{dsc inc|cpp/utility/pair/dsc get}}
-{{dcl list end}}
+{{dsc end}}
 ===Helper classes===
-{{dcl list begin}}
+{{dsc begin}}
-{{dcl list template | cpp/utility/pair/dcl list tuple_size}}
+{{dsc inc|cpp/utility/pair/dsc tuple_size}}
-{{dcl list template | cpp/utility/pair/dcl list tuple_element}}
+{{dsc inc|cpp/utility/pair/dsc tuple_element}}
-{{dcl list end}}
+{{dsc inc|cpp/utility/pair/dsc basic_common_reference}}
+{{dsc inc|cpp/utility/pair/dsc common_type}}
+{{dsc inc|cpp/utility/format/dsc tuple_formatter|pair}}
+{{dsc end}}
+===Helper specializations===
+{{dcl begin}}
+{{dcl|since=c++23|1=
+template< class T, class U >
+constexpr bool enable_nonlocking_formatter_optimization<std::pair<T, U>>
+ = enable_nonlocking_formatter_optimization<T> &&
+   enable_nonlocking_formatter_optimization<U>;
+}}
+{{dcl end}}
+This specialization of {{ltt std|cpp/utility/format/enable_nonlocking_formatter_optimization}} enables efficient implementation of {{ltt std|cpp/io/print}} and {{ltt std|cpp/io/println}} for printing a {{tt|pair}} object when both {{tt|T}} and {{tt|U}} enable it.
+==={{rl|deduction_guides|Deduction guides}}{{mark since c++17}}===
+===Defect reports===
+{{dr list begin}}
+{{dr list item|wg=lwg|dr=2796|std=C++98|before=triviality of the destructor of {{tt|pair}} was unspecified|after=specified}}
+{{dr list end}}
+===See also===
+{{dsc begin}}
+{{dsc inc|cpp/utility/dsc tuple}}
+{{dsc inc|cpp/utility/tuple/dsc tie}}
+{{dsc end}}
+{{langlinks|cs|de|es|fr|it|ja|ko|pl|pt|ru|zh}}

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Execution support library (C++26)
Technical specifications
Symbols index
External libraries

Member type	Definition
`first_type`	`T1`
`second_type`	`T2`

Member name	Type
`first`	`T1`
`second`	`T2`

(constructor)	constructs new `pair` (public member function) [edit]
operator=	assigns the contents (public member function) [edit]
swap (C++11)	swaps the contents (public member function) [edit]

cppreference.com

Namespaces

Variants

Views

Actions

Difference between revisions of "cpp/utility/pair"

Latest revision as of 04:28, 24 July 2024

Contents

[edit] Template parameters

[edit] Member types

[edit] Member objects

[edit] Member functions

[edit] Non-member functions

[edit] Helper classes

[edit] Helper specializations

[edit] Deduction guides(since C++17)

[edit] Defect reports

[edit] See also

Navigation

Toolbox