Difference between revisions of "cpp/utility/pair"
m (~) |
m (apply DR23: P3235R3. more std::enable_nonlocking_formatter_optimization specializations) |
||
| Line 54: | Line 54: | ||
{{dsc inc|cpp/utility/format/dsc tuple_formatter|pair}} | {{dsc inc|cpp/utility/format/dsc tuple_formatter|pair}} | ||
{{dsc end}} | {{dsc end}} | ||
| + | |||
| + | ===Helper specializations=== | ||
| + | {{dcl begin}} | ||
| + | {{dcl|since=c++23|1= | ||
| + | template< class T, class U > | ||
| + | inline 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}}=== | ==={{rl|deduction_guides|Deduction guides}}{{mark since c++17}}=== | ||
Revision as of 18:56, 4 July 2024
| Defined in header <utility>
|
||
| template< class T1, |
||
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.
Contents |
Template parameters
| T1, T2 | - | the types of the elements that the pair stores. |
Member types
| Member type | Definition |
first_type
|
T1
|
second_type
|
T2
|
Member objects
| Member name | Type |
first
|
T1
|
second
|
T2
|
Member functions
constructs new pair (public member function) | |
| assigns the contents (public member function) | |
| (C++11) |
swaps the contents (public member function) |
Non-member functions
creates a pair object of type, determined by the argument types (function template) | |
| (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) |
| (C++11) |
specializes the std::swap algorithm (function template) |
| (C++11) |
accesses an element of a pair (function template) |
Helper classes
| (C++11) |
obtains the size of a pair (class template specialization) |
obtains the type of the elements of pair (class template specialization) | |
determines the common reference type of two pairs (class template specialization) | |
| (C++23) |
determines the common type of two pairs (class template specialization) |
| (C++23) |
formatting support for pair (class template specialization) |
Helper specializations
| template< class T, class U > inline constexpr bool enable_nonlocking_formatter_optimization<std::pair<T, 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.
Deduction guides(since C++17)
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 |
See also
| (C++11) |
implements fixed size container, which holds elements of possibly different types (class template) |
| (C++11) |
creates a tuple of lvalue references or unpacks a tuple into individual objects (function template) |
