Макрос Foreach для аргументов макроса

Поскольку вы соглашаетесь с тем, что препроцессор имеет VA_ARGS (в C99, но не в текущем стандарте C ++), вы можете использовать P99. Это именно то, что вы просите: P99_FOR. Он работает без грубого синтаксиса ()()() от BOOST. Интерфейс просто

P99_FOR(NAME, N, OP, FUNC,...) 

и вы можете использовать его с чем-то вроде

#define P00_SEP(NAME, I, REC, RES) REC; RES
#define P00_VASSIGN(NAME, X, I) X = (NAME)[I]
#define MYASSIGN(NAME, ...) P99_FOR(NAME, P99_NARG(__VA_ARGS__), P00_SEP, P00_VASSIGN, __VA_ARGS__)

MYASSIGN(A, toto, tutu);

Да, рекурсивные макросы возможны в C с использованием причудливого обходного пути. Конечная цель - создать макрос MAP, который работает следующим образом:

#define PRINT(a) printf(#a": %d", a)
MAP(PRINT, a, b, c) /* Apply PRINT to a, b, and c */

Базовая рекурсия

Во-первых, нам нужна техника для генерации чего-то, что выглядит как вызов макроса, но еще не сделано:

#define MAP_OUT

Представьте, что у нас есть следующие макросы:

#define A(x) x B MAP_OUT (x)
#define B(x) x A MAP_OUT (x)

При оценке макроса A (blah) выводится текст:

blah B (blah)

Препроцессор не видит никакой рекурсии, поскольку вызов B (blah) в этот момент представляет собой просто текст, а B даже не является именем текущего макроса. Передача этого текста обратно в препроцессор расширяет вызов, производя вывод:

blah blah A (blah)

Оценка вывода в третий раз расширяет макрос A (blah), выполняя полный круг рекурсии. Рекурсия продолжается до тех пор, пока вызывающий объект продолжает подавать выходной текст обратно в препроцессор.

Для выполнения этих повторных вычислений следующий макрос EVAL передает свои аргументы вниз по дереву вызовов макросов:

#define EVAL0(...) __VA_ARGS__
#define EVAL1(...) EVAL0 (EVAL0 (EVAL0 (__VA_ARGS__)))
#define EVAL2(...) EVAL1 (EVAL1 (EVAL1 (__VA_ARGS__)))
#define EVAL3(...) EVAL2 (EVAL2 (EVAL2 (__VA_ARGS__)))
#define EVAL4(...) EVAL3 (EVAL3 (EVAL3 (__VA_ARGS__)))
#define EVAL(...)  EVAL4 (EVAL4 (EVAL4 (__VA_ARGS__)))

Каждый уровень умножает усилия предыдущего уровня, в сумме оценивая входные данные 365 раз. Другими словами, вызов EVAL (A (blah)) приведет к созданию 365 копий слова blah, за которым следует окончательная неоцененная B (blah). Это обеспечивает базовую основу для рекурсии, по крайней мере, в пределах определенной глубины стека.

Обнаружение конца

Следующая задача - остановить рекурсию, когда она достигнет конца списка.

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

#define MAP_END(...)

Оценка этого макроса ничего не делает, что завершает рекурсию.

Чтобы выбрать один из двух макросов, следующий макрос MAP_NEXT сравнивает отдельный элемент списка со специальным маркером конца списка (). Макрос возвращает MAP_END, если элемент соответствует, или параметр next, если элемент является другим:

#define MAP_GET_END() 0, MAP_END
#define MAP_NEXT0(item, next, ...) next MAP_OUT
#define MAP_NEXT1(item, next) MAP_NEXT0 (item, next, 0)
#define MAP_NEXT(item, next)  MAP_NEXT1 (MAP_GET_END item, next)

Этот макрос работает, помещая элемент рядом с макросом MAP_GET_END. Если это формирует вызов макроса, все перемещается на слот в списке параметров MAP_NEXT0, изменяя вывод. Уловка MAP_OUT не позволяет препроцессору оценить окончательный результат.

Собираем все вместе

С этими частями теперь можно реализовать полезные версии макросов A и B из приведенного выше примера:

#define MAP0(f, x, peek, ...) f(x) MAP_NEXT (peek, MAP1) (f, peek, __VA_ARGS__)
#define MAP1(f, x, peek, ...) f(x) MAP_NEXT (peek, MAP0) (f, peek, __VA_ARGS__)

Эти макросы применяют операцию f к текущему элементу списка x. Затем они исследуют следующий элемент списка, peek, чтобы увидеть, следует ли им продолжить или нет.

Последний шаг - связать все вместе в макрос MAP верхнего уровня:

#define MAP(f, ...) EVAL (MAP1 (f, __VA_ARGS__, (), 0))

Этот макрос помещает маркер () в конец списка, а также дополнительный 0 для соответствия ANSI (в противном случае последняя итерация будет иметь недопустимый список нулевой длины). Затем он передает все это через EVAL и возвращает результат.

Я загрузил этот код как библиотеку на github для вашего удобства.

Используя PPNARG, я написал набор макросов для применения макроса к каждому аргументу в макросе. Я называю это вариативным X-макросом.

/*
 * The PP_NARG macro evaluates to the number of arguments that have been
 * passed to it.
 *
 * Laurent Deniau, "__VA_NARG__," 17 January 2006, <comp.std.c> (29 November 2007).
 */
#define PP_NARG(...)    PP_NARG_(__VA_ARGS__,PP_RSEQ_N())
#define PP_NARG_(...)   PP_ARG_N(__VA_ARGS__)

#define PP_ARG_N( \
        _1, _2, _3, _4, _5, _6, _7, _8, _9,_10,  \
        _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \
        _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \
        _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \
        _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \
        _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \
        _61,_62,_63,N,...) N

#define PP_RSEQ_N() \
        63,62,61,60,                   \
        59,58,57,56,55,54,53,52,51,50, \
        49,48,47,46,45,44,43,42,41,40, \
        39,38,37,36,35,34,33,32,31,30, \
        29,28,27,26,25,24,23,22,21,20, \
        19,18,17,16,15,14,13,12,11,10, \
        9,8,7,6,5,4,3,2,1,0

PPNARG позволяет нам подсчитать количество аргументов. Затем мы добавляем это число к имени макроса и вызываем его с исходными аргументами.

/* need extra level to force extra eval */
#define Paste(a,b) a ## b
#define XPASTE(a,b) Paste(a,b)


/* APPLYXn variadic X-Macro by M Joshua Ryan      */
/* Free for all uses. Don't be a jerk.            */
/* I got bored after typing 15 of these.          */
/* You could keep going upto 64 (PPNARG's limit). */
#define APPLYX1(a)           X(a)
#define APPLYX2(a,b)         X(a) X(b)
#define APPLYX3(a,b,c)       X(a) X(b) X(c)
#define APPLYX4(a,b,c,d)     X(a) X(b) X(c) X(d)
#define APPLYX5(a,b,c,d,e)   X(a) X(b) X(c) X(d) X(e)
#define APPLYX6(a,b,c,d,e,f) X(a) X(b) X(c) X(d) X(e) X(f)
#define APPLYX7(a,b,c,d,e,f,g) \
    X(a) X(b) X(c) X(d) X(e) X(f) X(g)
#define APPLYX8(a,b,c,d,e,f,g,h) \
    X(a) X(b) X(c) X(d) X(e) X(f) X(g) X(h)
#define APPLYX9(a,b,c,d,e,f,g,h,i) \
    X(a) X(b) X(c) X(d) X(e) X(f) X(g) X(h) X(i)
#define APPLYX10(a,b,c,d,e,f,g,h,i,j) \
    X(a) X(b) X(c) X(d) X(e) X(f) X(g) X(h) X(i) X(j)
#define APPLYX11(a,b,c,d,e,f,g,h,i,j,k) \
    X(a) X(b) X(c) X(d) X(e) X(f) X(g) X(h) X(i) X(j) X(k)
#define APPLYX12(a,b,c,d,e,f,g,h,i,j,k,l) \
    X(a) X(b) X(c) X(d) X(e) X(f) X(g) X(h) X(i) X(j) X(k) X(l)
#define APPLYX13(a,b,c,d,e,f,g,h,i,j,k,l,m) \
    X(a) X(b) X(c) X(d) X(e) X(f) X(g) X(h) X(i) X(j) X(k) X(l) X(m)
#define APPLYX14(a,b,c,d,e,f,g,h,i,j,k,l,m,n) \
    X(a) X(b) X(c) X(d) X(e) X(f) X(g) X(h) X(i) X(j) X(k) X(l) X(m) X(n)
#define APPLYX15(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) \
    X(a) X(b) X(c) X(d) X(e) X(f) X(g) X(h) X(i) X(j) X(k) X(l) X(m) X(n) X(o)
#define APPLYX_(M, ...) M(__VA_ARGS__)
#define APPLYXn(...) APPLYX_(XPASTE(APPLYX, PP_NARG(__VA_ARGS__)), __VA_ARGS__)

А вот несколько примеров с выводом gcc -E в комментариях.

/* Example */
#define X(a) #a,
char *list[] = {
    APPLYXn(sugar,coffee,drink,smoke)
};
#undef X

/* Produces (gcc -E)
char *list[] = {
    "sugar", "coffee", "drink", "smoke",
};
 */


#define c1(a) case a:
#define c2(a,b)     c1(a) c1(b)
#define c3(a,b,c)   c1(a) c2(b,c)
#define c4(a,b,c,d) c1(a) c3(b,c,d)
#define c_(M, ...) M(__VA_ARGS__)
#define cases(...) c_(XPASTE(c, PP_NARG(__VA_ARGS__)), __VA_ARGS__)


//cases(3,4,5,6,7)
//produces
//case 3: case 4: case 5: case 6:


#define r_(a,b) range(a,b)
#define range(a,b) a,r_(a+1,b-1)
//range(3,4)

#define ps1(a) O ## a ();
#define ps2(a,b)     ps1(a) ps1(b)
#define ps3(a,b,c)   ps1(a) ps2(b,c)
#define ps4(a,b,c,d) ps1(a) ps3(b,c,d)
#define ps_(M, ...) M(__VA_ARGS__)
#define ps(...)     ps_(XPASTE(ps, PP_NARG(__VA_ARGS__)), __VA_ARGS__)

//ps(dup,add,sub)

Последнее было мотивом для всего этого. Но это оказалось не очень полезным.

В C ++ без расширений вы можете использовать Boost.Preprocessor и его последовательности:

PRINT_ALL((a)(b)(c));

Используя BOOST_PP_SEQ_FOR_EACH() в последовательности, вы можете перебирать ее и легко генерировать код, который их печатает.

Непроверенный простой образец:

#define DO_PRINT(elem) std::cout << BOOST_PP_STRINGIZE(elem) << "=" << (elem) << "\n";
#define PRINT_ALL(seq) { BOOST_PP_SEQ_FOR_EACH(DO_PRINT, _, seq) }

Старый вопрос, но я подумал, что выберу решение, которое придумал, чтобы использовать Boost.Preprocessor без уродливого синтаксиса (a)(b).

Заголовок:

#include <iostream>
#include <boost\preprocessor.hpp>

#define _PPSTUFF_OUTVAR1(_var) BOOST_PP_STRINGIZE(_var) " = " << (_var) << std::endl
#define _PPSTUFF_OUTVAR2(r, d, _var) << _PPSTUFF_OUTVAR1(_var) 
#define _PPSTUFF_OUTVAR_SEQ(vseq) _PPSTUFF_OUTVAR1(BOOST_PP_SEQ_HEAD(vseq)) \
        BOOST_PP_SEQ_FOR_EACH(_PPSTUFF_OUTVAR2,,BOOST_PP_SEQ_TAIL(vseq)) 
#define OUTVAR(...) _PPSTUFF_OUTVAR_SEQ(BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))

Использование:

int a = 3;
char b[] = "foo";

std::cout << OUTVAR(a);

// Expands to: 
//
// std::cout << "a" " = " << (a ) << std::endl  ;
//
// Output:
//
// a = 3

std::cout << OUTVAR(a, b);

// Expands to: 
//
// std::cout << "a" " = " << (a ) << std::endl << "b" " = " << (b) << std::endl  ;
//
// Output:
//
// a = 3
// b = foo

Красиво и чисто.

Конечно, вы можете заменить std::endl запятой или чем-то еще, если хотите, чтобы все это было в одной строке.

Вы можете использовать Boost.PP (после добавления папки Boost boost в список включаемых каталогов) макросы для этого. Вот пример (протестирован с GCC 8.1.0):

#include <iostream>
#include <limits.h>
#include <boost/preprocessor.hpp>

#define WRITER(number,middle,elem) std::cout << \
    number << BOOST_PP_STRINGIZE(middle) << elem << "\n";
#define PRINT_ALL(...) \
    BOOST_PP_SEQ_FOR_EACH(WRITER, =>, BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))

int main (int argc, char *argv[])
{
    PRINT_ALL(INT_MAX, 123, "Hello, world!");
}

Вывод:

2=>2147483647
3=>123
4=>Hello, world!

Часть BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__) преобразует список переменных-аргументов в традиционный способ Boost выражения нескольких аргументов в виде одного аргумента, который выглядит следующим образом: (item1)(item2)(item3).

Не уверен, почему он начинает нумеровать аргументы с двух. В документации описывается только первый параметр как "следующий доступный BOOST_PP_FOR повтор ».

Вот еще один пример, который определяет enum с возможностью записи его в виде строки в ostream, который также включает lexical_cast<string> Boost:

#define ENUM_WITH_TO_STRING(ENUMTYPE, ...)                   \
    enum ENUMTYPE {                                          \
        __VA_ARGS__                                          \
    };                                                       \
    inline const char* to_string(ENUMTYPE value) {           \
        switch (value) {                                     \
            BOOST_PP_SEQ_FOR_EACH(_ENUM_TO_STRING_CASE, _,   \
               BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))        \
            default: return nullptr;                         \
        }                                                    \
    }                                                        \
    inline std::ostream& operator<<(std::ostream& os, ENUMTYPE v)\
        { return os << to_string(v); }
#define _ENUM_TO_STRING_CASE(_,__,elem)                      \
    case elem: return BOOST_PP_STRINGIZE(elem);

ENUM_WITH_TO_STRING(Color, Red, Green, Blue)

int main (int argc, char *argv[])
{
    std::cout << Red << Green << std::endl;
    std::cout << boost::lexical_cast<string>(Blue) << std::endl;
}

Вывод:

RedGreen
Blue

Препроцессор недостаточно мощный, чтобы делать подобные вещи. Однако препроцессор вам не так уж и нужен. Если все, что вам нужно, это удобно выгрузить имена переменных и их значения. У вас может быть два простых макроса:

#define PRINT(x) \
{ \
    std::ostringstream stream; \
    stream << x; \
    std::cout << stream.str() << std::endl; \
}

#define VAR(v) #v << ": " << v << ", "

Тогда вы могли бы почти использовать свое предполагаемое использование:

int a = 1, b = 3, d = 0;
PRINT(VAR(a) << VAR(b) << VAR(d))

Это печатает

a: 1, b: 3, d: 0,

Есть много способов сделать это более мощным, но это работает, позволяет красиво печатать нецелочисленные значения, и это довольно простое решение.