A.6.1. Расширение пакета параметров

We use cookies. Read the Privacy and Cookie Policy

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

template<typename ... Params>

struct dummy {

 std::tuple<Params...> data;

};

В данном случае единственная переменная-член data представляет собой конкретизацию std::tuple<>, содержащую все заданные типы, то есть в классе dummy<int, double, char> имеется член типа std::tuple<int, double, char>. Расширение пакета можно комбинировать с обычными типами:

template<typename ... Params>

struct dummy2 {

 std::tuple<std::string, Params...> data;

};

На этот раз класс tuple имеет дополнительный (первый) член типа std::string. Есть еще одна красивая возможность: разрешается определить образец, в который будут подставляться все элементы расширения пакета. Для этого в конце образца размещается многоточие ..., обозначающее расширение пакета. Например, вместо кортежа элементов тех типов, которые перечислены в пакете параметров, можно создать кортеж указателей на такие типы или даже кортеж интеллектуальных указателей std::unique_ptr<> на них:

template<typename ... Params>

struct dummy3 {

 std::tuple<Params* ...> pointers;

 std::tuple<std::unique_ptr<Params> ...> unique_pointers;

};

Типовое выражение может быть сколь угодно сложным при условии, что в нем встречается пакет параметров и после него находится многоточие ..., обозначающее расширение. Во время расширения пакета параметров каждый элемент пакета подставляется в типовое выражение и порождает соответственный элемент в результирующем списке. Таким образом, если пакет параметров Params содержит типы int, int, char, то расширение выражения std::tuple<std::pair<std::unique_ptr<Params>, double> ... > дает std::tuple<std::pair<std::unique_ptr<int>, double>, std::pair<std::unique_ptr<int>, double>, std::pair<std::unique_ptr<char>, double>>. Если расширение пакета используется в качестве списка аргументов шаблона, то шаблон не обязан иметь переменные параметры, но если таковых действительно нет, то размер пакета должен быть в точности равен количеству требуемых параметров шаблона:

template<typename ... Types>

struct dummy4 {

 std::pair<Types...> data;

};                   │ Правильно, данные имеют

dummy4<int, char> a;←┘ вид std::pair<int, char>

dummy4<int> b; ← Ошибка, нет второго типа

dummy4<int, int, int> с;← Ошибка, слишком много типов

Еще один способ применения расширения пакета — объявление списка параметров функции:

template<typename ... Args>

void foo(Args ... args);

При этом создается новый пакет параметров args, являющийся списком параметров функции, а не списком типов, и его можно расширить с помощью ..., как и раньше. Теперь для объявления параметров функции можно использовать образец, в который производится подстановка типов из расширения пакета, — точно так же, как при подстановке расширения пакета в образец в других местах. Например, вот как это применяется в конструкторе std::thread, чтобы все аргументы функции принимались по ссылке на r-значение (см. раздел А.1):

template<typename CallableType, typename ... Args>

thread::thread(CallableType&& func, Args&& ... args);

Теперь пакет параметров функции можно использовать для вызова другой функции, указав расширение пакета в списке аргументов вызываемой функции. Как и при расширении типов, образец можно использовать для каждого выражения в результирующем списке аргументов. Например, при работе со ссылками на r-значения часто применяется идиома, заключающаяся в использовании std::forward<> для сохранения свойства «является r-значением» переданных функции аргументов:

template<typename ... ArgTypes>

void bar(ArgTypes&& ... args) {

 foo(std::forward<ArgTypes>(args)...);

}

Отметим, что в этом случае расширение пакета содержит как пакет типов ArgTypes, так и пакет параметров функции args, а многоточие расположено после всего выражения в целом. Если вызвать bar следующим образом:

int i;

bar(i, 3.141, std::string("hello "));

то расширение примет такой вид:

template<>

void bar<int&, double, std::string>(

 int& args_1,

 double&& args_2,

 std::string&& args_3) {

 foo(std::forward<int&>(args_1),

 std::forward<double>(args_2),

 std::forward<std::string>(args_3));

}

и, следовательно, первый аргумент правильно передается функции foo как ссылка на l-значение, а остальные — как ссылки на r-значения.

И последнее, что можно сделать с пакетом параметров, — это узнать его размер с помощью оператора sizeof.... Это совсем просто: sizeof...(p) возвращает число элементов в пакете параметров p. Неважно, является ли p пакетом параметров-типов или пакетом аргументов функции, — результат будет одинаковый. Это, пожалуй, единственный случай, где пакет параметров употребляется без многоточия, поскольку многоточие уже является частью оператора sizeof.... Следующая функция возвращает число переданных ей аргументов:

template<typename ... Args>

unsigned count_args(Args ... args) {

 return sizeof... (Args);

}

Как и для обычного оператора sizeof, результатом sizeof... является константное выражение, которое, следовательно, можно использовать для задания границ массива и т.п.