C++17 STL Стандартная библиотека шаблонов

  Попытка скомпилировать эти примеры в разных компиляторах в режиме C++11 или C++14 покажет, что одни компиляторы автоматически выводят тип auto x {123}; как int, а другие — как std::initializer_list. Подобный код может вызвать проблемы с переносимостью!

Разрешаем конструктору автоматически выводить полученный тип класса шаблона

Многие классы C++ обычно специализируются по типам, о чем легко догадаться по типам переменных, которые пользователь задействует при вызовах конструктора. Тем не менее до С++17 эти возможности не были стандартизированы. С++17 позволяет компилятору автоматически вывести типы шаблонов из вызовов конструктора.

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

Данную особенность очень удобно проиллюстрировать на примере создания экземпляров типа std::pair и std::tuple. Это можно сделать за один шаг:

std::pair my_pair (123, "abc");         // std::pair

std::tuple my_tuple (123, 12.3, "abc"); // std::tuple

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

Определим класс-пример, где автоматическое выведение типа шаблона будет выполняться на основе переданных значений:

template

class my_wrapper {

  T1 t1;

  T2 t2;

  T3 t3;

public:

  explicit my_wrapper(T1 t1_, T2 t2_, T3 t3_)

    : t1{t1_}, t2{t2_}, t3{t3_}

  {}

  /* … */

};

О’кей, это всего лишь еще один класс шаблона. Вот как мы раньше создавали его объект (инстанцировали шаблон):

my_wrapper wrapper {123, 1.23, "abc"};

Теперь же можно опустить специализацию шаблона:

my_wrapper wrapper {123, 1.23, "abc"};

До появления C++17 это было возможно только при реализации вспомогательной функции:

my_wrapper make_wrapper(T1 t1, T2 t2, T3 t3)

{

  return {t1, t2, t3};

}

Используя подобные вспомогательные функции, можно было добиться такого же эффекта:

auto wrapper (make_wrapper(123, 1.23, "abc"));

  STL предоставляет множество аналогичных инструментов: std::make_shared, std::make_unique, std::make_tuple и т.д. В C++17 эти функции могут считаться устаревшими. Но, конечно, они все еще будут работать для обеспечения обратной совместимости.

Дополнительная информация

Из данного примера мы узнали о неявном выведении типа шаблона. Однако в некоторых случаях на этот способ нельзя полагаться. Рассмотрим следующий класс-пример:

template

struct sum {

  T value;

  template

  sum(Ts&& ... values) : value{(values + ...)} {}

};

Эта структура, sum, принимает произвольное количество параметров и суммирует их с помощью выражений свертки (пример, связанный с выражениями свертки, мы рассмотрим далее в этой главе). Полученная сумма сохраняется в переменную-член value. Теперь вопрос заключается в том, что за тип — T? Если мы не хотим указывать его явно, то ему следует зависеть от типов значений, переданных в конструктор. В случае передачи объектов-строк тип должен быть std::string. При передаче целых чисел тип должен быть int. Если мы передадим целые числа, числа с плавающей точкой и числа с удвоенной точностью, то компилятору следует определить, какой тип подходит всем значениям без потери точности. Для этого мы предоставляем явные правила выведения типов:

template

sum(Ts&& ... ts) -> sum<std::common_type_t>;

Согласно этим правилам компилятор может использовать типаж std::common_ type_t, который способен определить, какой тип данных подходит всем значениям. Посмотрим, как его применить:

sum s {1u, 2.0, 3, 4.0f};

sum string_sum {std::string{"abc"}, "def"};

std::cout << s.value << '\n'

          << string_sum.value << '\n';

В первой строке мы создаем объект типа sum на основе аргументов конструктора, имеющих типы unsigned, double, int и float. Типаж std::common_type_t возвращает тип double, поэтому мы получаем объект типа sum. Во второй строке мы предоставляем экземпляр типа std::string и строку в стиле C. В соответствии с нашими правилами компилятор создает экземпляр типа sum.

При запуске этот код выведет значение 10 как результат сложения чисел и abcdef в качестве результата объединения строк.

Упрощаем принятие решений во время компиляции с помощью constexpr-if