Розширення варіативного пакета шаблонів

Я намагаюся вивчити різноманітні шаблони та функції. Я не можу зрозуміти, чому цей код не компілюється:

template<typename T>
static void bar(T t) {}

template<typename... Args>
static void foo2(Args... args)
{
    (bar(args)...);
}

int main()
{
    foo2(1, 2, 3, "3");
    return 0;    
}

Коли я компілюю, це не вдається з помилкою:

Помилка C3520: 'args': у цьому контексті потрібно розгорнути пакет параметрів

(у функції foo2).

Одне з місць, де може відбутися розширення пакета, знаходиться всередині спискового списку ініціалізації . Ви можете скористатися цим, розмістивши розширення всередині списку ініціалізаторів фіктивного масиву:

template<typename... Args>
static void foo2(Args &&... args)
{
    int dummy[] = { 0, ( (void) bar(std::forward<Args>(args)), 0) ... };
}

Щоб пояснити зміст ініціалізатора більш докладно:

{ 0, ( (void) bar(std::forward<Args>(args)), 0) ... };
  |       |       |                        |     |
  |       |       |                        |     --- pack expand the whole thing 
  |       |       |                        |   
  |       |       --perfect forwarding     --- comma operator
  |       |
  |       -- cast to void to ensure that regardless of bar()'s return type
  |          the built-in comma operator is used rather than an overloaded one
  |
  ---ensure that the array has at least one element so that we don't try to make an
     illegal 0-length array when args is empty

Демо .

Важливою перевагою розширення в {}тому, що це гарантує оцінку зліва направо.

За допомогою C ++ 17- кратних виразів ви можете просто писати

((void) bar(std::forward<Args>(args)), ...);

Пакети параметрів можуть бути розширені лише в суворо визначеному переліку контекстів, і оператор ,не є одним із них. Іншими словами, неможливо використовувати розширення пакета, щоб сформувати вираз, що складається з серії підвиразів, розділених оператором ,.

Правило великого пальця «Розширення може створити список з ,-Поділ шаблонів , де ,є список роздільниками.» Оператор ,не створює список у граматичному сенсі.

Щоб викликати функцію для кожного аргументу, ви можете використовувати рекурсію (яка є основним інструментом у вікні програміста варіадичного шаблону):

template <typename T>
void bar(T t) {}

void foo2() {}

template <typename Car, typename... Cdr>
void foo2(Car car, Cdr... cdr)
{
  bar(car);
  foo2(cdr...);
}

int main()
{
  foo2 (1, 2, 3, "3");
}

Живий приклад

БЕЗСОРОННА КОПІЯ _{[затверджено джерелом]}

Пакети параметрів можуть бути розширені лише в суворо визначеному переліку контекстів, і оператор ,не є одним із них. Іншими словами, неможливо використовувати розширення пакета, щоб сформувати вираз, що складається з серії підвиразів, розділених оператором ,.

Основне правило: "Розширення може створити список розділених ,шаблонів, де ,є роздільник списку." Оператор ,не створює список у граматичному сенсі.

Щоб викликати функцію для кожного аргументу, ви можете використовувати рекурсію (яка є основним інструментом у вікні програміста варіадичного шаблону):

#include <utility>

template<typename T>
void foo(T &&t){}

template<typename Arg0, typename Arg1, typename ... Args>
void foo(Arg0 &&arg0, Arg1 &&arg1, Args &&... args){
    foo(std::forward<Arg0>(arg0));
    foo(std::forward<Arg1>(arg1), std::forward<Args>(args)...);
}

auto main() -> int{
    foo(1, 2, 3, "3");
}

КОРИСНА НЕКОпійована інформація

Ще одна річ, яку ви, мабуть, не бачили в цій відповіді, - це використання &&специфікатора та std::forward. У C ++ &&специфікатор може означати одну з двох речей: rvalue-reference або універсальні посилання.

Я не буду вдаватися до rvalue-посилань, але до когось, хто працює з варіативними шаблонами; універсальні посилання - це боже послання.

Ідеальне пересилання

Одним із застосувань std::forwardта універсальних посилань є ідеальне пересилання типів на інші функції.

У вашому прикладі, якщо ми передаємо int&в foo2нього автоматично буде знижений intз - за підписом генерується foo2функції після шаблону дедукції , і якщо ви хочете , щоб потім переслати цю argіншу функцію , яка буде змінювати його по посиланню, ви отримаєте непередбачувані результати ( змінна не буде змінена), оскільки foo2буде передаватися посилання на тимчасове, створене шляхом передачі intйому. Щоб обійти це, ми вказуємо функцію пересилання, яка приймає будь-який тип посилання на змінну (rvalue або lvalue). Потім, щоб бути впевненим, що ми передаємо точний тип, переданий у функції пересилання, яку ми використовуємо std::forward, тоді і тількитоді ми дозволяємо зниження типів; тому що ми зараз у точці, де це найважливіше.

Якщо вам потрібно, читайте більше про універсальні посилання та ідеальну пересилання ; Скотт Мейерс досить чудовий як ресурс.

Рішення C ++ 17 для цього дуже близьке до очікуваного коду:

template<typename T>
static void bar(T t) {}

template<typename... Args>
static void foo2(Args... args) {
    (bar(args), ...);
}

int main() {
    foo2(1, 2, 3, "3");
    return 0;    
}

Це розширює шаблон за допомогою оператора кома між кожним виразом

// imaginary expanded expression
(bar(1), bar(2), bar(3), bar("3"));

Ви можете використовувати make_tupleдля розширення пакета, оскільки воно вводить контекст, де ,послідовність, створена розширенням, є дійсною

make_tuple( (bar(std::forward<Args>(args)), 0)... );

Тепер я підозрюю, що невикористаний / безіменний / тимчасовий кортеж нулів, який утворюється, виявляється компілятором та оптимізується.

Демо

Це повний приклад, заснований на відповідях тут.

Приклад для відтворення, console.logяк показано в JavaScript:

Console console;
console.log("bunch", "of", "arguments");
console.warn("or some numbers:", 1, 2, 3);
console.error("just a prank", "bro");

Ім'я файлу, наприклад js_console.h:

#include <iostream>
#include <utility>

class Console {
protected:
    template <typename T>
    void log_argument(T t) {
        std::cout << t << " ";
    }
public:
    template <typename... Args>
    void log(Args&&... args) {
        int dummy[] = { 0, ((void) log_argument(std::forward<Args>(args)),0)... };
        cout << endl;
    }

    template <typename... Args>
    void warn(Args&&... args) {
        cout << "WARNING: ";
        int dummy[] = { 0, ((void) log_argument(std::forward<Args>(args)),0)... };
        cout << endl;
    }

    template <typename... Args>
    void error(Args&&... args) {
        cout << "ERROR: ";
        int dummy[] = { 0, ((void) log_argument(std::forward<Args>(args)),0)... };
        cout << endl;
    }
};