std::tuple<Types...>::tuple - cppreference.com (original) (raw)

Constructs a new tuple.

In the descriptions that follow, let

• i be in the range [​0​, sizeof...(Types)) in order,
• Ti be the ith type in Types, and
• Ui be the ith type in a template parameter pack named UTypes,

where indexing is zero-based.

1. Default constructor. Value-initializes all elements, if any. The default constructor is trivial if sizeof...(Types) == 0.

• This overload participates in overload resolution only if std::is_default_constructible<Ti>::value is true for all i.
• The constructor is explicit if and only if Ti is not copy-list-initializable from {} for at least one i.

1. Direct constructor. Initializes each element of the tuple with the corresponding parameter.

• This overload participates in overload resolution only if sizeof...(Types) >= 1 and std::is_copy_constructible<Ti>::value is true for all i.
• This constructor is explicit if and only if std::is_convertible<const Ti&, Ti>::value is false for at least one i.

1. Converting constructor. Initializes each element of the tuple with the corresponding value in std::forward<UTypes>(args).

• This overload participates in overload resolution only if
  • sizeof...(Types) == sizeof...(UTypes),
  • sizeof...(Types) >= 1,
  • std::is_constructible<Ti, Ui>::value is true for all i, and
  • let D be std::decay<U0>::type(until C++20)std::remove_cvref_t<U0>(since C++20),
    * if sizeof...(Types) == 1, then D is not std::tuple, otherwise,
    * if sizeof...(Types) == 2 or sizeof...(Types) == 3, then either D is not std::allocator_arg_t, or T0 is std::allocator_arg_t.
• The constructor is explicit if and only if std::is_convertible<Ui, Ti>::value is false for at least one i.

4-7) Converting constructor. Initializes each element of the tuple with the corresponding element of other.

Formally, let FWD(other) be std::forward<decltype(other)>(other), for all i, initializes ith element of the tuple with std::get<i>(FWD(other)).

• This overload participates in overload resolution only if
  • sizeof...(Types) == sizeof...(UTypes),
  • std::is_constructible_v<Ti, decltype(std::get<i>(FWD(other)))> is true for all i, and
  • either
    * sizeof...(Types) is not 1, or
    * (when Types... expands to T and UTypes... expands to U) std::is_convertible_v<decltype(other), T>, std::is_constructible_v<T, decltype(other)>, and std::is_same_v<T, U> are all false.
• These constructors are explicit if and only if std::is_convertible_v<decltype(std::get<i>(FWD(other))), Ti> is false for at least one i.

8-11) Pair constructor. Constructs a 2-element tuple with each element constructed from the corresponding element of p.

Formally, let FWD(p) be std::forward<decltype(p)>(p), initializes the first element with std::get<0>(FWD(p)) and the second element with std::get<1>(FWD(p)).

• This overload participates in overload resolution only if
  • sizeof...(Types) == 2,
  • std::is_constructible_v<T0, decltype(std::get<0>(FWD(p)))> is true, and
  • std::is_constructible_v<T1, decltype(std::get<1>(FWD(p)))> is true.
• The constructor is explicit if and only if std::is_convertible_v<decltype(std::get<0>(FWD(p))), T0> or std::is_convertible_v<decltype(std::get<1>(FWD(p))), T1> is false.

1. tuple-like constructor. Constructs a tuple with each element constructed from the corresponding element of u.

Formally, for all i, initializes ith element of the tuple with std::get<i>(std::forward<UTuple>(u)).

• This overload participates in overload resolution only if
  • std::same_as<std::remove_cvref_t<UTuple>, std::tuple> is false,
  • std::remove_cvref_t<UTuple> is not a specialization of std::ranges::subrange,
  • sizeof...(Types) equals std::tuple_size_v<std::remove_cvref_t<UTuple>>,
  • std::is_constructible_v<Ti, decltype(std::get<i>(std::forward<UTuple>(u)))> is true for all i, and
  • either
    * sizeof...(Types) is not 1, or
    * (when Types... expands to T) std::is_convertible_v<UTuple, T> and std::is_constructible_v<T, UTuple> are both false.
• This constructor is defined as deleted if the initialization of any element that is a reference would bind it to a temporary object.

1. Implicitly-defined copy constructor. Initializes each element of the tuple with the corresponding element of other.

• This constructor is constexpr if every operation it performs is constexpr. For the empty tuple std::tuple<>, it is constexpr.
• std::is_copy_constructible<Ti>::value must be true for all i, otherwise the behavior is undefined(until C++20)the program is ill-formed(since C++20).

1. Implicitly-defined move constructor. For all i, initializes the ith element of the tuple with std::forward<Ui>(std::get<i>(other)).

• This constructor is constexpr if every operation it performs is constexpr. For the empty tuple std::tuple<>, it is constexpr.
• std::is_move_constructible<Ti>::value must be true for all i, otherwise the behavior is undefined(until C++20)this overload does not participate in overload resolution(since C++20).

15-28) Identical to (1-14) except each element is created by uses-allocator construction, that is, the Allocator object a is passed as an additional argument to the constructor of each element for which std::uses_allocator<Ui, Alloc>::value is true.

[edit] Parameters

[edit] Notes

Conditionally-explicit constructors make it possible to construct a tuple in copy-initialization context using list-initialization syntax:

Note that if some element of the list is not implicitly convertible to the corresponding element of the target tuple, the constructors become explicit:

using namespace std::chrono; void launch_rocket_at(std::tuple<hours, minutes, seconds>);   launch_rocket_at({hours(1), minutes(2), seconds(3)}); // OK launch_rocket_at({1, 2, 3}); // Error: int is not implicitly convertible to duration launch_rocket_at(std::tuple<hours, minutes, seconds>{1, 2, 3}); // OK

[edit] Example

#include #include #include #include #include #include #include #include   // helper function to print a vector to a stream template<class Os, class T> Os& operator<<(Os& os, std::vector const& v) { os << '{'; for (auto i{v.size()}; const T& e : v) os << e << (--i ? "," : ""); return os << '}'; }   template void print_single(T const& v) { if constexpr (std::is_same_v<T, std::decay_t<std::string>>) std::cout << std::quoted(v); else if constexpr (std::is_same_v<std::decay_t, char>) std::cout << "'" << v << "'"; else std::cout << v; }   // helper function to print a tuple of any size template<class Tuple, std::size_t N> struct TuplePrinter { static void print(const Tuple& t) { TuplePrinter<Tuple, N - 1>::print(t); std::cout << ", "; print_single(std::get<N - 1>(t)); } };   template struct TuplePrinter<Tuple, 1> { static void print(const Tuple& t) { print_single(std::get<0>(t)); } };   template<class... Args> void print(std::string_view message, const std::tuple<Args...>& t) { std::cout << message << " ("; TuplePrinter<decltype(t), sizeof...(Args)>::print(t); std::cout << ")\n"; } // end helper function   int main() { std::tuple<int, std::string, double> t1; print("Value-initialized, t1:", t1);   std::tuple<int, std::string, double> t2{42, "Test", -3.14}; print("Initialized with values, t2:", t2);   std::tuple<char, std::string, int> t3{t2}; print("Implicitly converted, t3:", t3);   std::tuple<int, double> t4{std::make_pair(42, 3.14)}; print("Constructed from a pair, t4:", t4);   // given Allocator my_alloc with a single-argument constructor // my_alloc(int); use my_alloc(1) to allocate 5 ints in a vector using my_alloc = std::allocator; std::vector<int, my_alloc> v{5, 1, my_alloc{/* 1 /}};   // use my_alloc(2) to allocate 5 ints in a vector in a tuple std::tuple<int, std::vector<int, my_alloc>, double> t5 {std::allocator_arg, my_alloc{/ 2 */}, 42, v, -3.14}; print("Constructed with allocator, t5:", t5); }

Possible output:

Value-initialized, t1: (0, "", 0) Initialized with values, t2: (42, "Test", -3.14) Implicitly converted, t3: ('*', "Test", -3) Constructed from a pair, t4: (42, 3.14) Constructed with allocator, t5: (42, {1,1,1,1,1}, -3.14)

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit] See also