std::tuple_element - cppreference.com (original) (raw)

Provides compile-time indexed access to the types of the elements of a tuple-like type.

1. The primary template is not defined. An explicit (full) or partial specialization is required to make a type tuple-like.

2-4) Specializations for cv-qualified types simply add corresponding cv-qualifiers by default.

Contents

• 1 Specializations
• 2 Member types
• 3 Helper types
• 4 Notes
• 5 Example
• 6 Defect reports
• 7 See also

[edit] Specializations

The standard library provides following specializations for standard library types:

Users may specialize std::tuple_element for program-defined types to make them tuple-like.

In normal cases where the get functions returns reference members or reference to subobjects, only specializations for cv-unqualified types are needed to be customized.

[edit] Member types

[edit] Helper types

| | | | | ------------------------------------------------------------------------------------------------------------------------------- | | ------------- | | template< std::size_t I, class T > using tuple_element_t = typename tuple_element<I, T>::type; | | (since C++14) |

[edit] Notes

[edit] Example

#include #include #include #include #include #include #include   template<typename T1, typename T2, typename T3> struct Triple { T1 t1; T2 t2; T3 t3; };   // A specialization of std::tuple_element for program-defined type Triple: template<std::size_t I, typename T1, typename T2, typename T3> struct std::tuple_element<I, Triple<T1, T2, T3>> { static_assert(false, "Invalid index"); }; template<typename T1, typename T2, typename T3> struct std::tuple_element<0, Triple<T1, T2, T3>> { using type = T1; }; template<typename T1, typename T2, typename T3> struct std::tuple_element<1, Triple<T1, T2, T3>> { using type = T2; }; template<typename T1, typename T2, typename T3> struct std::tuple_element<2, Triple<T1, T2, T3>> { using type = T3; };     template<typename... Args> struct TripleTypes { static_assert(3 == sizeof...(Args), "Expected exactly 3 type names"); template<std::size_t N> using type = typename std::tuple_element_t<N, Triple<Args...>>; };   int main() { TripleTypes<char, int, float>::type<1> i{42}; std::cout << i << '\n';   using Tri = Triple<int, char, short>; //< Program-defined type static_assert(std::is_same_v<std::tuple_element_t<0, Tri>, int> && std::is_same_v<std::tuple_element_t<1, Tri>, char> && std::is_same_v<std::tuple_element_t<2, Tri>, short>);   using Tuple = std::tuple<int, char, short>; static_assert(std::is_same_v<std::tuple_element_t<0, Tuple>, int> && std::is_same_v<std::tuple_element_t<1, Tuple>, char> && std::is_same_v<std::tuple_element_t<2, Tuple>, short>);   using Array3 = std::array<int, 3>; static_assert(std::is_same_v<std::tuple_element_t<0, Array3>, int> && std::is_same_v<std::tuple_element_t<1, Array3>, int> && std::is_same_v<std::tuple_element_t<2, Array3>, int>);   using Pair = std::pair<Tuple, Tri>; static_assert(std::is_same_v<std::tuple_element_t<0, Pair>, Tuple> && std::is_same_v<std::tuple_element_t<1, Pair>, Tri>);   using Sub = std::ranges::subrange<int*, int*>; static_assert(std::is_same_v<std::tuple_element_t<0, Sub>, int*> && std::is_same_v<std::tuple_element_t<1, Sub>, int*>); }

Output:

[edit] Defect reports

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

[edit] See also