◐ Shell
clean mode source ↗

std::tuple_element — cppreference.com

<tbody> </tbody>

Определено в заголовочном файле <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 для определяемых программой типов, чтобы сделать их tuple-подобными.

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

Типы элементы

Тип элемент Определение
type для стандартной специализации тип Iго элемента T типа tuple-like, где I находится в диапазоне [0, std::tuple_size<T>::value)

Вспомогательные типы

<tbody> </tbody>

Определено в заголовочном файле <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 типов не требовались в некоторых заголовках,
что приводило к двусмысленности 		требуются

Смотрите также