std::tuple

Определён в заголовочном файле `<tuple>`
template< class... Types > class tuple;		(начиная с C++11)

Шаблон класса std::tuple — это коллекция разнородных значений фиксированного размера. Он является обобщением std::pair.

Если для каждого Ti в Types выполняется условие std::is_trivially_destructible<Ti>::value является true, деструктор std::tuple является тривиальным.

Если программа объявляет явную или частичную специализацию std::tuple, программа некорректна, диагностика не требуется.

Параметры шаблона

Types...

типы элементов, которые хранит кортеж. Допускается пустой список.

Функции-члены

(конструктор)	создаёт новый `tuple` (открытая функция-член)
operator=	присваивает содержимое одного `tuple` другому (открытая функция-член)
swap	обменивает содержимое двух `tuple`s (открытая функция-член)

Функции, не являющиеся членами

make_tuple (C++11)	создаёт объект `tuple` типа, определённого типами аргументов (шаблон функции)
tie (C++11)	создаёт `tuple` ссылок lvalue или распаковывает кортеж в отдельные объекты (шаблон функции)
forward_as_tuple (C++11)	создаёт `tuple` пересылающих ссылок (шаблон функции)
tuple_cat (C++11)	создаёт `tuple`, объединяя любое количество кортежей (шаблон функции)
get(std::tuple) (C++11)	получает указанный элемент кортежа (шаблон функции)
operator==operator!=operator<operator<=operator>operator>=operator<=> (удалён в C++20)(удалён в C++20)(удалён в C++20)(удалён в C++20)(удалён в C++20)(C++20)	лексикографически сравнивает значения в кортеже (шаблон функции)
std::swap(std::tuple) (C++11)	специализирует алгоритм `std::swap` (шаблон функции)

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

tuple-likepair-like

(C++23)

задаёт условие, что тип реализует протокол кортежа
(std::get, std::tuple_element, std::tuple_size)
(концепт только для описания*)

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

std::tuple_size<std::tuple> (C++11)	получает размер `tuple` (специализация шаблона класса)
std::tuple_element<std::tuple> (C++11)	получает тип указанного элемента (специализация шаблона класса)
std::uses_allocator<std::tuple> (C++11)	специализирует типовой признак `std::uses_allocator` (специализация шаблона класса)
std::basic_common_reference<tuple-like> (C++23)	определяет общий ссылочный тип для типа `tuple` и типа `tuple-like` (специализация шаблона класса)
std::common_type<tuple-like> (C++23)	определяет общий тип для типа `tuple` и типа `tuple-like` (специализация шаблона класса)
std::formatter<std::tuple> (C++23)	поддержка форматирования `tuple` (специализация шаблона класса)
ignore (C++11)	заполнитель для пропуска элемента при распаковке `tuple` с помощью `tie` (константа)

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

template< class... Ts >
constexpr bool enable_nonlocking_formatter_optimization<std::tuple<Ts...>> 
 = (enable_nonlocking_formatter_optimization<Ts> && ...);

(начиная с C++23)

Эта специализация std::enable_nonlocking_formatter_optimization обеспечивает эффективную реализацию std::print и std::println для вывода объекта tuple, если это поддерживается типом каждого элемента.

Руководства по выводу типов (начиная с C++17)

Примечания

До принятия N4387 (применённого в качестве отчёта об ошибке для C++11) функция не могла возвращать кортеж с использованием копирующей инициализации списком:

std::tuple<int, int> foo_tuple()
{
    return {1, -1};  // Error until N4387
    return std::tuple<int, int>{1, -1}; // Always works
    return std::make_tuple(1, -1); // Always works
}

Пример

#include <iostream>
#include <stdexcept>
#include <string>
#include <tuple>

std::tuple<double, char, std::string> get_student(int id)
{
    switch (id)
    {
        case 0: return {3.8, 'A', "Lisa Simpson"};
        case 1: return {2.9, 'C', "Milhouse Van Houten"};
        case 2: return {1.7, 'D', "Ralph Wiggum"};
        case 3: return {0.6, 'F', "Bart Simpson"};
    }
    
    throw std::invalid_argument("id");
}

int main()
{
    const auto student0 = get_student(0);
    std::cout << "ID: 0, "
              << "GPA: " << std::get<0>(student0) << ", "
              << "grade: " << std::get<1>(student0) << ", "
              << "name: " << std::get<2>(student0) << '\n';
    
    const auto student1 = get_student(1);
    std::cout << "ID: 1, "
              << "GPA: " << std::get<double>(student1) << ", "
              << "grade: " << std::get<char>(student1) << ", "
              << "name: " << std::get<std::string>(student1) << '\n';
    
    double gpa2;
    char grade2;
    std::string name2;
    std::tie(gpa2, grade2, name2) = get_student(2);
    std::cout << "ID: 2, "
              << "GPA: " << gpa2 << ", "
              << "grade: " << grade2 << ", "
              << "name: " << name2 << '\n';
    
    // C++17 structured binding:
    const auto [gpa3, grade3, name3] = get_student(3);
    std::cout << "ID: 3, "
              << "GPA: " << gpa3 << ", "
              << "grade: " << grade3 << ", "
              << "name: " << name3 << '\n';
}

Вывод:

ID: 0, GPA: 3.8, grade: A, name: Lisa Simpson
ID: 1, GPA: 2.9, grade: C, name: Milhouse Van Houten
ID: 2, GPA: 1.7, grade: D, name: Ralph Wiggum
ID: 3, GPA: 0.6, grade: F, name: Bart Simpson

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

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

DR	Применён к	Поведение согласно опубликованному стандарту	Исправленное поведение
LWG 2796	C++11	тривиальность деструктора `std::tuple` не была определена	определена
LWG 3990	C++11	программа могла объявить явную или частичную специализацию `std::tuple`	в этом случае программа некорректна (диагностика не требуется)

Ссылки

Стандарт C++23 (ISO/IEC 14882:2024):

22.4 Кортежи [tuple]

Стандарт C++20 (ISO/IEC 14882:2020):

20.5 Кортежи [tuple]

Стандарт C++17 (ISO/IEC 14882:2017):

23.5 Кортежи [tuple]

Стандарт C++14 (ISO/IEC 14882:2014):

20.4 Кортежи [tuple]

Стандарт C++11 (ISO/IEC 14882:2011):

20.4 Кортежи [tuple]

См. также

pair	реализует двоичный кортеж, то есть пару значений (шаблон класса)

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