variadic templates

template<class... Args> — параметр-пакет (parameter pack), представляющий ноль или более типов сразу. Функция или класс с таким шаблоном может принимать произвольное число аргументов произвольных типов, а пакет разворачивается через синтаксис Args... в местах, где нужен список типов или значений.template<class... Args> — a parameter pack, representing zero or more types at once. A function or class built on such a template can accept an arbitrary number of arguments of arbitrary types, and the pack is expanded via the Args... syntax wherever a list of types or values is needed.

void print(); // база рекурсии// recursion base case
template <class T>
void print(T a) { std::cout << a; }
template <class T1, class T2>
void print(T1 a, T2 b) { print(a); print(b); }
// ...и так для каждого числа аргументов// ...and so on for every argument count

void print() {}                    // база рекурсии// recursion base case

template <class T, class... Rest>
void print(T first, Rest... rest) {
    std::cout << first;
    print(rest...);                 // рекурсивное разворачивание// recursive unpacking
}

До C++11 переменное число аргументов в шаблонном коде решалось плохо:Before C++11, variable argument counts in template code were handled poorly:

Компилятор инстанцирует отдельную функцию (или класс) для каждого конкретного набора типов, с которым вызван шаблон — сам параметр-пакет не существует в рантайме, это чисто механизм этапа компиляции. Разворачивание пакета (...) — операция, которую компилятор применяет к паттерну, содержащему пакет, порождая список через запятую или рекурсивный вызов.The compiler instantiates a separate function (or class) for each concrete set of types the template is invoked with — the parameter pack itself doesn't exist at runtime, it's a purely compile-time mechanism. Pack expansion (...) is an operation the compiler applies to a pattern containing the pack, producing a comma-separated list or a recursive call.

template <class... Args>
void log(Args&&... args) {           // args — параметр-пакет// args is a parameter pack
    (std::cout << ... << args);       // C++17 fold expression, для контраста;// C++17 fold expression, shown for contrast;
}                                      // в C++11 — только явная рекурсия (см. print выше)// in C++11 — only explicit recursion (see print above)

template <class T, class... Args>
std::unique_ptr<T> make_unique(Args&&... args) {
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
    // Args&&... args — пакет universal references,// Args&&... args — a pack of universal references,
    // std::forward<Args>(args)... — разворачивание с forward на каждый элемент// std::forward<Args>(args)... — expansion with forward applied to each element
}

// sizeof...(Args) — число элементов в пакете, вычисляется на этапе компиляции// sizeof...(Args) — the number of elements in the pack, computed at compile time
template <class... Args>
constexpr std::size_t count() { return sizeof...(Args); }

В C++11 единственный способ обработать пакет поэлементно — рекурсия с базовым случаем (перегрузка без пакета или с одним элементом); fold expressions ((... op args)), которые убирают эту рекурсию, — фича C++17.In C++11, the only way to process a pack element by element is recursion with a base case (an overload with no pack, or with a single element); fold expressions ((... op args)), which eliminate that recursion, are a C++17 feature.

• cppreference — Parameter pack
• WG21 N2242 — Variadic Templates (revised)