std::tuple_element

`<tuple>`
`<array>`
`<utility>`
`<ranges>`		( C++20)
`template< std::size_t I, class T > struct tuple_element; //`	(1)	( C++11)
`template< std::size_t I, class T > struct tuple_element< I, const T > { using type = typename std::add_const<typename std::tuple_element<I, T>::type>::type; };`	(2)	( C++11)
`template< std::size_t I, class T > struct tuple_element< I, volatile T > { using type = typename std::add_volatile<typename std::tuple_element<I, T>::type>::type; };`	(3)	( C++11) ( C++20)
`template< std::size_t I, class T > struct tuple_element< I, const volatile T > { using type = typename std::add_cv<typename std::tuple_element<I, T>::type>::type; };`	(4)	( C++11) ( C++20)

tuple-like.

1) . tuple-, () .

2-4) cv- cv- .

std::tuple_element : tuple.

( C++17)

:

std::tuple_element<std::tuple> (C++11)	( ) []
std::tuple_element<std::pair> (C++11)	`pair` ( ) []
std::tuple_element<std::array> (C++11)	`array` ( ) []
std::tuple_element<std::ranges::subrange> (C++20)	std::ranges::subrange ( ) []

std::tuple_element , tuple-.

, get , cv- .



type	`I` `T` tuple-like, `I` `[0,` `std::tuple_size<T>::value)`

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


`__cpp_lib_tuple_element_t`	`201402L`	(C++14)	`std::tuple_element_t`

#include <array>
#include <cstddef>
#include <iostream>
#include <ranges>
#include <tuple>
#include <type_traits>
#include <utility>

template <typename T1, typename T2, typename T3>
    struct Triple { T1 t1; T2 t2; T3 t3; };

//  std::tuple_element f -  Triple:
template <std::size_t I, typename T1, typename T2, typename T3>
    struct std::tuple_element<I, Triple<T1, T2, T3>>
    { static_assert(false, " "); }; 
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), "  3  !");
    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>; //< - 
    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*>);
}

:

C++:


LWG 2212	C++11	cv ,

(C++17)	[]
tuple_size (C++11)	tuple ( ) []
tuple_cat (C++11)	`tuple`, ( ) []

cppreference.com

std::tuple_element