Difference between revisions of "cpp/utility/tuple/make tuple"
From cppreference.com
(→Possible implementation: tweak) |
m (→Example: fmt) |
||
| (5 intermediate revisions by 5 users not shown) | |||
| Line 2: | Line 2: | ||
{{cpp/utility/tuple/navbar}} | {{cpp/utility/tuple/navbar}} | ||
{{dcl begin}} | {{dcl begin}} | ||
| − | {{dcl header | tuple | + | {{dcl header|tuple}} |
| − | + | {{dcl|since=c++11|notes={{mark|constexpr since C++14}}|1= | |
| − | {{dcl | since=c++11 | | + | |
template< class... Types > | template< class... Types > | ||
| − | tuple<VTypes...> make_tuple( Types&&... args ); | + | std::tuple<VTypes...> make_tuple( Types&&... args ); |
}} | }} | ||
| − | |||
| − | |||
| − | |||
| − | |||
| − | |||
{{dcl end}} | {{dcl end}} | ||
Creates a tuple object, deducing the target type from the types of arguments. | Creates a tuple object, deducing the target type from the types of arguments. | ||
| − | For each {{tt|Ti}} in {{tt|Types...}}, the corresponding type {{tt|Vi}} in {{tt| | + | For each {{tt|Ti}} in {{tt|Types...}}, the corresponding type {{tt|Vi}} in {{tt|VTypes...}} is {{c|std::decay<Ti>::type}} unless application of {{lc|std::decay}} results in {{c|std::reference_wrapper<X>}} for some type {{tt|X}}, in which case the deduced type is {{tt|X&}}. |
===Parameters=== | ===Parameters=== | ||
{{par begin}} | {{par begin}} | ||
| − | {{par | args | zero or more arguments to construct the tuple from}} | + | {{par|args|zero or more arguments to construct the tuple from}} |
{{par end}} | {{par end}} | ||
| Line 28: | Line 22: | ||
===Possible implementation=== | ===Possible implementation=== | ||
| − | {{eq fun | 1= | + | {{eq fun|1= |
template <class T> | template <class T> | ||
struct unwrap_refwrapper | struct unwrap_refwrapper | ||
| Line 42: | Line 36: | ||
template <class T> | template <class T> | ||
| − | using | + | using unwrap_decay_t = typename unwrap_refwrapper<typename std::decay<T>::type>::type; |
| + | // or use std::unwrap_ref_decay_t (since C++20) | ||
template <class... Types> | template <class... Types> | ||
| − | + | constexpr // since C++14 | |
| + | std::tuple<unwrap_decay_t<Types>...> make_tuple(Types&&... args) | ||
{ | { | ||
| − | return std::tuple< | + | return std::tuple<unwrap_decay_t<Types>...>(std::forward<Types>(args)...); |
} | } | ||
}} | }} | ||
===Example=== | ===Example=== | ||
| − | {{example | | + | {{example| |
| − | + | |code= | |
#include <iostream> | #include <iostream> | ||
#include <tuple> | #include <tuple> | ||
| Line 70: | Line 66: | ||
auto t = std::make_tuple(10, "Test", 3.14, std::ref(n), n); | auto t = std::make_tuple(10, "Test", 3.14, std::ref(n), n); | ||
n = 7; | n = 7; | ||
| − | std::cout << "The value of t is | + | std::cout << "The value of t is (" |
| − | << std::get<0>(t) << ", " << std::get<1>(t) << ", " | + | << std::get<0>(t) << ", " |
| − | << std::get<2>(t) << ", " << std::get<3>(t) << ", " | + | << std::get<1>(t) << ", " |
| + | << std::get<2>(t) << ", " | ||
| + | << std::get<3>(t) << ", " | ||
<< std::get<4>(t) << ")\n"; | << std::get<4>(t) << ")\n"; | ||
| Line 78: | Line 76: | ||
int a, b; | int a, b; | ||
std::tie(a, b) = f(); | std::tie(a, b) = f(); | ||
| − | std::cout << a << | + | std::cout << a << ' ' << b << '\n'; |
} | } | ||
| − | + | |output= | |
| − | The value of | + | The value of t is (10, Test, 3.14, 7, 1) |
5 7 | 5 7 | ||
}} | }} | ||
| + | ===See also=== | ||
{{dsc begin}} | {{dsc begin}} | ||
| − | {{dsc inc | cpp/utility/tuple/dsc tie}} | + | {{dsc inc|cpp/utility/tuple/dsc tie}} |
| − | {{dsc inc | cpp/utility/tuple/dsc forward_as_tuple}} | + | {{dsc inc|cpp/utility/tuple/dsc forward_as_tuple}} |
| − | {{dsc inc | cpp/utility/tuple/dsc tuple_cat}} | + | {{dsc inc|cpp/utility/tuple/dsc tuple_cat}} |
| + | {{dsc inc|cpp/utility/dsc apply}} | ||
{{dsc end}} | {{dsc end}} | ||
| − | + | {{langlinks|de|es|fr|it|ja|pt|ru|zh}} | |
| − | + | ||
| − | + | ||
| − | + | ||
| − | + | ||
| − | + | ||
| − | + | ||
| − | + | ||
Latest revision as of 08:46, 2 February 2023
| Defined in header <tuple>
|
||
| template< class... Types > std::tuple<VTypes...> make_tuple( Types&&... args ); |
(since C++11) (constexpr since C++14) |
|
Creates a tuple object, deducing the target type from the types of arguments.
For each Ti in Types..., the corresponding type Vi in VTypes... is std::decay<Ti>::type unless application of std::decay results in std::reference_wrapper<X> for some type X, in which case the deduced type is X&.
Contents |
[edit] Parameters
| args | - | zero or more arguments to construct the tuple from |
[edit] Return value
A std::tuple object containing the given values, created as if by std::tuple<VTypes...>(std::forward<Types>(t)...).
[edit] Possible implementation
template <class T> struct unwrap_refwrapper { using type = T; }; template <class T> struct unwrap_refwrapper<std::reference_wrapper<T>> { using type = T&; }; template <class T> using unwrap_decay_t = typename unwrap_refwrapper<typename std::decay<T>::type>::type; // or use std::unwrap_ref_decay_t (since C++20) template <class... Types> constexpr // since C++14 std::tuple<unwrap_decay_t<Types>...> make_tuple(Types&&... args) { return std::tuple<unwrap_decay_t<Types>...>(std::forward<Types>(args)...); } |
[edit] Example
Run this code
#include <iostream> #include <tuple> #include <functional> std::tuple<int, int> f() // this function returns multiple values { int x = 5; return std::make_tuple(x, 7); // return {x,7}; in C++17 } int main() { // heterogeneous tuple construction int n = 1; auto t = std::make_tuple(10, "Test", 3.14, std::ref(n), n); n = 7; std::cout << "The value of t is (" << std::get<0>(t) << ", " << std::get<1>(t) << ", " << std::get<2>(t) << ", " << std::get<3>(t) << ", " << std::get<4>(t) << ")\n"; // function returning multiple values int a, b; std::tie(a, b) = f(); std::cout << a << ' ' << b << '\n'; }
Output:
The value of t is (10, Test, 3.14, 7, 1) 5 7
[edit] See also
| (C++11) |
creates a tuple of lvalue references or unpacks a tuple into individual objects (function template) |
| (C++11) |
creates a tuple of forwarding references (function template) |
| (C++11) |
creates a tuple by concatenating any number of tuples (function template) |
| (C++17) |
calls a function with a tuple of arguments (function template) |
