std::tuple_element

Определён в заголовке `<tuple>`
Определён в заголовке `<array>`
Определён в заголовке `<utility>`
Определён в заголовке `<ranges>`		(начиная с C++20)
Определён в заголовке `<complex>`		(начиная с C++26)
template< std::size_t I, class T > struct tuple_element; // not defined	(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-like, требуется явная полная или частичная специализация.

2-4) Специализации для типов с cv-квалификаторами по умолчанию просто добавляют соответствующие cv-квалификаторы.

std::tuple_element взаимодействует с основным языком: в случае tuple-like он может обеспечить поддержку структурных связываний.

(начиная с 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)	получает тип итератора или sentinel-типа `std::ranges::subrange` (специализация шаблона класса)
std::tuple_element<std::complex> (C++26)	получает тип вещественной и мнимой частей `std::complex` (специализация шаблона класса)

Пользователи могут специализировать std::tuple_element для типов, определённых в программе, чтобы сделать их tuple-like.

В обычных случаях, когда функции get возвращают ссылочные элементы или ссылки на подобъекты, достаточно настроить специализации только для типов без cv-квалификаторов.

Типы-члены

Тип-член	Определение
type	для стандартной специализации — тип `I`-го элемента типа tuple-like `T`, где `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;
};

// 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*>);
}

Вывод:

Отчёты об ошибках

Следующие отчёты об ошибках, изменяющие поведение, были применены ретроспективно к ранее опубликованным стандартам C++.

DR	Применяется к	Поведение согласно опубликованному тексту	Корректное поведение
LWG 2212	C++11	в некоторых заголовках специализации для типов с cv-квалификаторами не требовались, что приводило к неоднозначности	требуются

См. также

Структурное связывание (C++17)	связывает указанные имена с подобъектами или элементами кортежа инициализатора
tuple_size (C++11)	получает количество элементов типа tuple-like (шаблон класса)
tuple_cat (C++11)	создаёт `tuple` путём конкатенации любого количества кортежей (шаблон функции)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/utility/tuple_element