std::tuple

Кортеж произвольной длины из стандартной библиотеки C++

std::tuple — шаблонный тип, который хранит фиксированное число значений разных типов в одном объекте. Это обобщение std::pair на произвольное число элементов: если pair<A, B> хранит два значения, то tuple<A, B, C, D, ...> — сколько угодно.

#include <tuple>
#include <string>

std::tuple<int, std::string, double> t{42, "hello", 3.14};

std::tuple<int, double, std::string> a(1, 2.5, "hi");
std::tuple<int, double, std::string> b{1, 2.5, "hi"};  // uniform init, C++11

auto t = std::make_tuple(1, 2.5, std::string("hi"));
// тип выведется сам: std::tuple<int, double, std::string>

Функция make_tuple выводит типы из аргументов — это удобнее, чем выписывать их вручную. Один нюанс: make_tuple("hi") даёт tuple<const char*>, а не tuple<std::string>. Если хочется именно строку — оборачивай явно.

std::tuple t{1, 2.5, std::string("hi")};  // типы выводятся сами, без make_tuple

С C++17 угловые скобки можно вообще опустить — компилятор выведет параметры шаблона из аргументов. Для короткого литерала "hi" всё равно получится const char*, так что для строк нужна явная обёртка.

Оператор [] у std::tuple не определён. Причина в том, что тип возвращаемого значения зависит от индекса, поэтому индекс обязан быть известен на этапе компиляции. Синтаксис — шаблонный параметр в угловых скобках:

std::tuple<int, std::string, double> t{42, "hello", 3.14};

int         x = std::get<0>(t);  // 42
std::string y = std::get<1>(t);  // "hello"
double      z = std::get<2>(t);  // 3.14

Если тип встречается в кортеже ровно один раз, можно спрашивать по нему:

auto s = std::get<std::string>(t);  // "hello"
auto n = std::get<int>(t);          // 42

Если тип встречается несколько раз — ошибка компиляции, надо использовать индекс.

std::get возвращает ссылку на элемент, значит через него можно и писать:

std::get<0>(t) = 100;
std::get<1>(t) += " world";

std::tuple<int, std::string, double> t{42, "hello", 3.14};

auto  [x, y, z] = t;         // копии
auto& [a, b, c] = t;         // ссылки — через них можно менять t
const auto& [p, q, r] = t;  // ссылки для чтения

Число имён в скобках должно точно совпадать с числом элементов кортежа — меньше или больше нельзя.

int x;
std::string y;
double z;

std::tie(x, y, z) = t;

// std::ignore — пропустить ненужное поле
std::tie(x, std::ignore, z) = t;

Исторически это был основной способ до C++17. Сейчас structured bindings почти всегда удобнее, но у std::tie остался важный идиоматический трюк — лексикографическое сравнение нескольких полей:

bool operator<(const Point& a, const Point& b) {
    return std::tie(a.x, a.y, a.z) < std::tie(b.x, b.y, b.z);
}

Без tie пришлось бы вручную расписывать каскад сравнений через if или &&.

auto a = std::make_tuple(1, 'a');
auto b = std::make_tuple("hi", 3.14);
auto c = std::tuple_cat(a, b);  // tuple<int, char, const char*, double>

int add3(int x, int y, int z) { return x + y + z; }

auto args = std::make_tuple(1, 2, 3);
int s = std::apply(add3, args);  // 6 — то же, что add3(1, 2, 3)

Очень удобно, когда аргументы заранее собраны в кортеж — например, при передаче через variadic templates или при работе с std::function.

Всё, что нужно в шаблонном коде для работы с кортежем как с последовательностью типов:

using T = std::tuple<int, std::string, double>;

// Размер кортежа (число элементов):
constexpr std::size_t sz  = std::tuple_size<T>::value;  // 3
constexpr std::size_t sz2 = std::tuple_size_v<T>;       // 3  (C++17)

// Тип элемента по индексу:
using SecondType    = std::tuple_element<1, T>::type;  // std::string
using SecondTypeAlt = std::tuple_element_t<1, T>;      // std::string  (C++14)

Комбинация tuple_size_v + tuple_element_t + std::make_index_sequence — стандартный набор для обхода кортежа в compile-time.

Кортежи сравниваются лексикографически, покомпонентно слева направо:

std::tuple<int, int, int> a{1, 2, 3};
std::tuple<int, int, int> b{1, 2, 4};

bool less = a < b;   // true: первые два равны, третий 3 < 4
bool eq   = a == b;  // false

Это ровно то, что нужно для составных ключей в std::set / std::map и для приоритетов в std::priority_queue. Именно поэтому в разборе «Constructing the Array» отрезки клались в кучу как tuple<int, int, int>: сначала длина, потом позиция — и priority_queue автоматически разруливала оба критерия приоритета.

#include <tuple>
#include <string>

std::tuple<bool, int, std::string> parseInput(const std::string& s) {
    // ... разбираем строку ...
    return {true, 42, "ok"};  // C++17: фигурные скобки без имени типа
}

int main() {
    auto [success, code, message] = parseInput("...");
    if (success) {
        // используем code и message
    }
}

До C++17 приходилось писать через std::tie с заранее объявленными переменными — получалось многословно:

bool success;
int code;
std::string message;
std::tie(success, code, message) = parseInput("...");

int i = getIndex();
auto x = std::get<i>(t);  // ОШИБКА: i не compile-time константа

Индекс обязан быть известен компилятору. Если нужна динамика — это не tuple.

std::tuple<int, int, double> t{1, 2, 3.0};
auto x = std::get<int>(t);  // ОШИБКА: int встречается дважды

auto t = std::make_tuple("hello");  // tuple<const char*>, не std::string!

Если нужна строка — оборачивай явно: std::make_tuple(std::string("hello")) или с литералом "hello"s из C++14 (после using namespace std::string_literals).

std::tuple<int, int, int> t{1, 2, 3};
auto [a, b] = t;  // ОШИБКА: нужно ровно 3 имени

// Плохо: объявляем переменную, которая не нужна:
int unused;
std::tie(x, unused, z) = t;

// Хорошо:
std::tie(x, std::ignore, z) = t;