Макрос макросов макросов

Ответ 1

Поскольку вы принимаете, что препроцессор имеет VA_ARGS (в C99, но не в текущем стандарте С++), вы можете перейти с 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);

Ответ 2

Да, в 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 (в противном случае последняя итерация имела бы незаконную 0-длинный список). Затем оно проходит через EVAL и возвращает результат.

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

Ответ 3

Используя 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 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)

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

Ответ 4

В С++ без расширений вы можете пойти 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) }

Ответ 5

Старый вопрос, но я думал, что приложу решение, которое я придумал для использования 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 запятой или чем-то, если хотите все это на одной строке.

Ответ 6

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

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

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

Ответ 7

Вы можете использовать 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, что также включает Boost lexical_cast<string>:

#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