Макросы с переменным числом аргументов с нулевыми аргументами не компилируются даже с ## __ VA_ARGS__

Важным фактом о макросах C / C ++ является то, что их невозможно вызвать без параметров, потому что параметр макроса может быть пустой последовательностью токенов.

Следовательно, DUMMY() вызывает макрос DUMMY с одним пустым параметром, а не с нулевыми параметрами. Это объясняет, почему работает второй пример, а также объясняет, почему первый пример вызывает синтаксическую ошибку.

Расширение GCC удаляет запятую из , ##__VA_ARGS__, когда __VA_ARGS__ не имеет элементов. Но один пустой аргумент - это не то же самое, что отсутствие аргументов. Когда вы определяете DUMMY как #define DUMMY(...) , вы гарантируете, что __VA_ARGS__ имеет хотя бы один аргумент, поэтому , не будет удален.

*** Примечание: GCC делает исключение из этого правила, если вы не укажете какой-либо стандарт ISO с параметром --std. В этом случае, если ... является единственным параметром макроса и вызов имеет пустой аргумент, тогда ,##__VA_ARGS__ удаляет запятую. Это указано в руководстве по CPP в раздел Variadic Marcos:

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

Когда DUMMY равно #define DUMMY(x, ...), __VA_ARGS будет пустым, если DUMMY вызывается только с одним аргументом, который включает как вызовы DUMMY() (один пустой аргумент), так и DUMMY(0) (один аргумент, 0). Обратите внимание, что стандартный C и C ++ до C ++ 20 не допускают этого вызова; они требуют, чтобы был хотя бы один (возможно, пустой) аргумент, соответствующий многоточию. Однако GCC никогда не налагал этого ограничения, и GCC будет опускать запятую с ,##__VA_ARGS__ независимо от параметра --std.

Начиная с C ++ 20, вы можете использовать встроенный макрос __VA_OPT__ как более стандартный способ работы с запятыми (и любыми другими знаками препинания, которые, возможно, потребуется удалить). __VA_OPT__ также позволяет избежать проблемы, представленной выше с пустыми аргументами, потому что он использует другой критерий: __VA_OPT__(x) заменяется на x, если __VA_ARGS__ содержит хотя бы один токен; в противном случае он расширяется до пустой последовательности. Следовательно, __VA_OPT__ будет работать должным образом для макросов в этом вопросе.

Я считаю, что все основные компиляторы теперь реализуют __VA_OPT__, по крайней мере, в своих последних версиях.

Стандартный __VA_ARGS__ не удаляет завершающий , при использовании нулевых аргументов. Ваш ##__VA_ARGS__, который удаляет лишние ,, является расширением GCC.

Это расширение GCC не работает, потому что вы используете стандартный совместимый режим -std=c++17 вместо -std=gnu++17.

По некоторым причинам (вероятно, это ошибка GCC), если вы используете только #define DUMMY(...) без других аргументов, ##__VA_ARGS__ не будет работать должным образом (запятую не удалит, если __VA_ARGS__ пусто).

Это верно только при компиляции с -std=c++17. Когда вы компилируете с -std=gnu++17, этого не происходит. Но в любом случае ##__VA_ARGS__ является расширением GCC, а код с ##__VA_ARGS__ вообще не должен компилироваться с -std=c++17. Но GCC позволяет использовать расширения GCC в режиме -std=c++17, если вы не установите флаг -pedantic. Но похоже, что расширения GCC по-разному работают в режиме -std=c++17 и -std=gnu++17.

Однако проблему можно обойти:

#include <utility>

template <typename... TArgs>
void Dummy(const TArgs &...args)
{
}

namespace WA
{
    class stub_t {};

    stub_t ArgOrStub()
    {
        return {};
    }

    template <typename T>
    auto ArgOrStub(T &&t) -> decltype( std::forward<T>(t) )
    {
        return std::forward<T>(t);
    }

    template <typename... TArgs>
    void RemoveStubAndCallDummy(stub_t, TArgs &&...args)
    {
        Dummy(std::forward<TArgs>(args)...);
    }

    template <typename... TArgs>
    void RemoveStubAndCallDummy(TArgs &&...args)
    {
        Dummy(std::forward<TArgs>(args)...);
    }
}

#define DUMMY(first, ...) WA::RemoveStubAndCallDummy( WA::ArgOrStub(first), ##__VA_ARGS__ )

int main()
{
    DUMMY();
}

Когда вы вызываете DUMMY(), аргумент first будет пустым, и после предварительной обработки мы получим WA::ArgOrStub(), который вернет stub_t, который позже будет удален первой перегрузкой RemoveStubAndCallDummy. Это громоздко, но лучшего решения я не нашел.