std::tuple_element

Определено в заголовочном файле `<tuple>`
Определено в заголовочном файле `<array>`
Определено в заголовочном файле `<utility>`
Определено в заголовочном файле `<ranges>`		(с C++20)
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) Основной шаблон не определён. Требуется явное (полное) или частичное специализирование для придания типу «кортеж-подобного» вида.

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

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

(с 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 для определённых программистом типов, чтобы сделать их «кортеж-подобными».

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

Типы-члены

Тип-член	Определение
type	для стандартной специализации, тип `I`-го элемента «кортеж-подобного» типа `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)

Примечания

Макрокоманда проверки наличия функции	Значение	Std	Функция
`__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_cat (C++11)	создаёт «кортеж-подобный» тип, конкатенируя любое количество кортежей (шаблон функции)

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