-----

Student "John Doe", ID: 234, GPA: 3.7

Student "Billy Foo", ID: 345, GPA: 4

Student "Cathy Bar", ID: 456, GPA: 3.5

-----

Student "John Doe", ID: 123, GPA: 3.7

-----

Student "John Doe", ID: 234, GPA: 3.7

Student "Billy Foo", ID: 345, GPA: 4

Student "Cathy Bar", ID: 456, GPA: 3.5

-----

Как это работает

Функция std::apply — это вспомогательная функция времени компиляции, которая позволяет нам работать, не имея сведений обо всех типах данных, которые появляются в нашем коде.

Допустим, у нас есть кортеж t со значениями (123, "abc"s, 456.0). Он имеет тип tuple<int, string, double>. Вдобавок предположим, что у нас есть функция f с сигнатурой int f(int, string, double) (типы также могут быть ссылками).

Затем можно написать конструкцию x = apply(f, t), которая приведет к вызову функции x = f(123, "abc"s, 456.0). Метод apply даже не возвращает результат работы функции f. 

Быстрое создание структур данных с помощью std::tuple

Взглянем на простой пример использования кортежей, с которым мы уже сталкивались. Мы можем определить следующую структуру, чтобы просто объединить некоторые переменные в одну сущность:

struct Foo {

  int a;

  string b;

  float c;

};

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

using Foo = tuple<int, string, float>;

Получить доступ к его элементам можно по порядковому номеру типа из списка типов. Для получения доступа к первому члену кортежа t напишем конструкцию std::get<0>(t); для получения доступа ко второму члену — std::get<1> и т.д. Если порядковый номер слишком велик, то компилятор безопасно сгенерирует ошибку.

На протяжении этой книги мы уже использовали возможности декомпозиции C++17 для кортежей. Она позволяет быстро разбить кортеж на элементы, просто написав auto [a,b,c] = some_tuple, чтобы получить доступ к отдельным элементам.

Композиция и декомпозиция отдельных структур данных — не единственная возможность, которую предоставляют кортежи. Мы также можем конкатенировать или разбивать кортежи. В этом разделе мы поэкспериментируем с данными функциями, чтобы узнать, как они работают.

Как это делается

В этом примере мы напишем программу, которая может динамически вывести на экран любой кортеж. Вдобавок напишем функцию, способную объединять кортежи.

1. Сначала включим несколько заголовочных файлов, а затем объявим об использовании пространства имен std:

#include <iostream>

#include <tuple>

#include <list>

#include <utility>

#include <string>

#include <iterator>

#include <numeric>

#include <algorithm>

using namespace std;

2. Поскольку мы будем работать с кортежами, было бы интересно отобразить их содержимое. Поэтому сейчас реализуем очень обобщенную функцию, которая может выводить на экран любые кортежи. Функция принимает ссылку на поток вывода os, которая будет использована для вывода данных на экран, и список аргументов переменной длины, содержащий все члены кортежа. Мы разбили на части все аргументы в первом элементе и поместили их в аргумент v, а остальные поместили в наборе параметров vs...:

template <typename T, typename Ts>

void print_args(ostream &os, const T &v, const Ts &. vs)

{

  os << v;

3. Если в наборе параметров еще есть аргументы, то они выводятся на экран, притом их разделяет символ ", " — используется прием с развертыванием initializer_list. Мы говорили о нем в главе 4.

  (void)initializer_list<int>{((os << ", " << vs), 0)...};

}

4. Теперь можно выводить на экран произвольное количество аргументов с помощью конструкции print_args(cout,1,2,"foo",3,"bar"), например. Но мы пока не трогали кортежи. Для вывода кортежей на экран переопределим оператор потока вывода <<, чтобы он работал с кортежами, реализовав шаблонную функцию, которая соответствует любым специализациям для кортежа:

template <typename ... Ts>

ostream& operator<<(ostream &os, const tuple<Ts...> &t)

{

5. Сейчас все станет чуть сложнее. Сначала мы воспользуемся лямбда-выражением, которое принимает произвольно большое количество параметров. При вызове выражение добавляет аргумент os в начало списка данных аргументов, а затем вызывает функцию print_args, передавая полученный новый список аргументов. Это значит, что вызов capt_tup(...некоторые параметры...) преобразуется в вызов print_args(os, ...некоторые параметры...).

  auto print_to_os ([&os](const auto &...xs) {

    print_args(os, xs...);

  });

6. Теперь можем выполнить распаковку кортежа. Для этого воспользуемся методом std::apply. Все значения будут извлечены из кортежа и представлены как аргументы функции для той функции, которую мы предоставили в качестве первого аргумента. Это значит, что если у нас есть кортеж t = (1,2,3) и мы вызываем метод apply(capt_tup,t), то эти действия приведут к вызову функции capt_tup(1,2,3), что, в свою очередь, повлечет вызов print_args(os,1,2,3). Это именно то, что нужно. Дополнительно окружим операцию вывода скобками:

  os << "(";

  apply(print_to_os, t);

  return os << ")";

}

7. О’кей, мы написали сложный фрагмент кода, который сделает нашу жизнь гораздо проще, если мы захотим вывести кортеж на экран. Но с помощью кортежей мы можем сделать больше. Допустим, напишем функцию, принимающую в качестве аргумента итерабельный диапазон данных, например вектор или список чисел. Эта функция проитерирует по данному диапазону и вернет сумму всех его чисел, а также минимальное, максимальное и среднее значения. Упаковывая эти четыре значения в кортеж, можем вернуть их как один объект, не определяя дополнительный тип структуры.

template <typename T>

tuple<double, double, double, double>

sum_min_max_avg(const T &range)

{

8. Функция std::minmax_element возвращает пару итераторов, указывающих на минимальный и максимальный элементы входного диапазона. Метод std::accumulate складывает все значения в данном диапазоне. Это все нужно, чтобы вернуть четыре значения, которые позже будут помещены в кортеж!

  auto min_max (minmax_element(begin(range), end(range)));

  auto sum (accumulate(begin(range), end(range), 0.0));

  return {sum, *min_max.first, *min_max.second,

          sum / range.size()};

}

9. Перед реализацией основной программы создадим последнюю волшебную вспомогательную функцию. Я называю ее волшебной, поскольку она на первый взгляд выглядит очень сложной, но если понять принцип ее работы, она покажется очень удобным помощником. Она сгруппирует два кортежа. Это значит, что если мы передадим ей кортежи (1,2,3) и