Макрос Foreach на аргументы макроса
Интересно, можно ли написать макрос foreach на аргументы макроса. Вот что хочу сделать:
#define PRINT(a) printf(#a": %d", a)
#define PRINT_ALL(...) ? ? ? THE PROBLEM ? ? ?
И возможное использование:
int a = 1, b = 3, d = 0;
PRINT_ALL(a,b,d);
Вот чего я достиг
#define FIRST_ARG(arg,...) arg
#define AFTER_FIRST_ARG(arg,...) , ##__VA_ARGS__
#define PRINT(a) printf(#a": %d", a)
#define PRINT_ALL PRINT(FIRST_ARG(__VA_ARGS__)); PRINT_ALL(AFTER_FIRST_ARG(__VA_ARGS__))
Это рекурсивный макрос, который недопустим. И еще одна проблема с этим stop condition рекурсии.
6 ответов
Поскольку вы принимаете, что препроцессор имеет 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);
Да, в Си возможны рекурсивные макросы, использующие причудливый обходной путь. Конечная цель - создать 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.
С помощью 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 (после добавления Boostboost папку в список включаемых каталогов), чтобы получить макросы для этого. Вот пример (протестирован с 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__) part преобразует список переменных-аргументов в традиционный способ Boost для выражения нескольких аргументов в виде одного аргумента, который выглядит следующим образом: (item1)(item2)(item3),
Не уверен, почему он начинает нумерацию аргументов в два. Документация просто описывает первый параметр как "следующее доступное повторение BOOST_PP_FOR ".
Вот еще один пример, который определяет enum с возможностью записи в виде строки в ostream, что также позволяет Boost's 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
Препроцессор не достаточно мощный, чтобы делать такие вещи. Однако вам не нужен препроцессор так сильно. Если все, что вы хотите сделать, это сбросить имена переменных и их значения удобным способом. Вы можете иметь два простых макроса:
#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,
Есть много способов сделать это более мощным, но это работает, позволяет красиво печатать нецелые значения, и это довольно простое решение.