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

да, рекурсивные макросы возможны в 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)) would произведите 365 копий слова blah, а затем окончательный un-evaluated 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 список параметров, изменение выходного. The 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 (в противном случае последняя итерация будет иметь незаконную 0-длина списка). Затем он пропускает все это через 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++ без расширений вы можете пойти на импульс.Препроцессор и его последовательности:

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.Препроцессор без уродливого (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 с запятой или чем-то еще, если вы хотите, чтобы все это было на одной строке.

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

#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,

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