Как работает этот? Как можно реализовать вариационный макрос C99/С++ 11 для расширения до разных вещей на основе того, сколько аргументов ему дано?
Могут ли макросы быть перегружены по количеству аргументов?
Ответ 1
(Изменить: см. конец готового решения.)
Чтобы получить перегруженный макрос, сначала нам нужен макрос, который выбирает между несколькими реализациями. Эта часть не использует переменный макрос. Тогда переменный макрос, который в общем случае учитывает его аргументы, производит селектор. Включение аргумента в диспетчер создает перегруженный макрос.
Предостережение:. Эта система не может определить разницу между нулем и одним аргументом, потому что нет никакой разницы между аргументом и единственным пустым аргументом. Оба они выглядят как MACRO().
Чтобы выбрать между реализациями, используйте оператор макроопределения с серией функциональных макросов.
#define select( selector, ... ) impl ## _ ## selector( __VA_ARGS__ )
#define impl_1() meh
#define impl_2( abc, xyz ) # abc "wizza" xyz()
//etc
// usage: select( 1 ) => impl_1() => meh
// select( 2, huz, bar ) => impl_2( huzza, bar ) => "huz" "wizza" bar()
Поскольку оператор ## подавляет макрораспределение своих аргументов, лучше его переносить в другой макрос.
#define CAT( A, B ) A ## B
#define SELECT( NAME, NUM ) CAT( NAME ## _, NUM )
Чтобы подсчитать аргументы, используйте __VA_ARGS__ для смещения таких аргументов (это умная часть):
#define GET_COUNT( _1, _2, _3, _4, _5, _6 /* ad nauseam */, COUNT, ... ) COUNT
#define VA_SIZE( ... ) GET_COUNT( __VA_ARGS__, 6, 5, 4, 3, 2, 1 )
Код библиотеки:
#define CAT( A, B ) A ## B
#define SELECT( NAME, NUM ) CAT( NAME ## _, NUM )
#define GET_COUNT( _1, _2, _3, _4, _5, _6 /* ad nauseam */, COUNT, ... ) COUNT
#define VA_SIZE( ... ) GET_COUNT( __VA_ARGS__, 6, 5, 4, 3, 2, 1 )
#define VA_SELECT( NAME, ... ) SELECT( NAME, VA_SIZE(__VA_ARGS__) )(__VA_ARGS__)
Использование:
#define MY_OVERLOADED( ... ) VA_SELECT( MY_OVERLOADED, __VA_ARGS__ )
#define MY_OVERLOADED_1( X ) foo< X >
#define MY_OVERLOADED_2( X, Y ) bar< X >( Y )
#define MY_OVERLOADED_3( X, Y, Z ) bang_ ## X< Y >.Z()
Ответ 2
Я бы опубликовал это как комментарий к сообщению Potatoswatter, но он слишком длинный и требует перечня кодов.
Вот немного кода perl для генерации набора макросов, которые предназначены для перегрузки макросов.
$ perl -le 'map{
$arity = $_; map {
$ar = 2 + $arity + $_; $arm = $ar - 1; $arlist = join("", map{"A$_, "} 1..$arity); $warlist = "WHAT, $arlist";
@li = map {"_$_"} 0..$_; $lis = join(", ", @li); $lim = pop @li; $lims = join(", ", @li);
print "#define FEI_${arity}A_$ar($warlist$lis) FEI_${arity}A_$arm($warlist$lims) WHAT($_, $arlist$lim)"
} 1..3; print ""
} 0..4'
Вот вывод script:
#define FEI_0A_3(WHAT, _0, _1) FEI_0A_2(WHAT, _0) WHAT(1, _1)
#define FEI_0A_4(WHAT, _0, _1, _2) FEI_0A_3(WHAT, _0, _1) WHAT(2, _2)
#define FEI_0A_5(WHAT, _0, _1, _2, _3) FEI_0A_4(WHAT, _0, _1, _2) WHAT(3, _3)
#define FEI_1A_4(WHAT, A1, _0, _1) FEI_1A_3(WHAT, A1, _0) WHAT(1, A1, _1)
#define FEI_1A_5(WHAT, A1, _0, _1, _2) FEI_1A_4(WHAT, A1, _0, _1) WHAT(2, A1, _2)
#define FEI_1A_6(WHAT, A1, _0, _1, _2, _3) FEI_1A_5(WHAT, A1, _0, _1, _2) WHAT(3, A1, _3)
#define FEI_2A_5(WHAT, A1, A2, _0, _1) FEI_2A_4(WHAT, A1, A2, _0) WHAT(1, A1, A2, _1)
#define FEI_2A_6(WHAT, A1, A2, _0, _1, _2) FEI_2A_5(WHAT, A1, A2, _0, _1) WHAT(2, A1, A2, _2)
#define FEI_2A_7(WHAT, A1, A2, _0, _1, _2, _3) FEI_2A_6(WHAT, A1, A2, _0, _1, _2) WHAT(3, A1, A2, _3)
#define FEI_3A_6(WHAT, A1, A2, A3, _0, _1) FEI_3A_5(WHAT, A1, A2, A3, _0) WHAT(1, A1, A2, A3, _1)
#define FEI_3A_7(WHAT, A1, A2, A3, _0, _1, _2) FEI_3A_6(WHAT, A1, A2, A3, _0, _1) WHAT(2, A1, A2, A3, _2)
#define FEI_3A_8(WHAT, A1, A2, A3, _0, _1, _2, _3) FEI_3A_7(WHAT, A1, A2, A3, _0, _1, _2) WHAT(3, A1, A2, A3, _3)
#define FEI_4A_7(WHAT, A1, A2, A3, A4, _0, _1) FEI_4A_6(WHAT, A1, A2, A3, A4, _0) WHAT(1, A1, A2, A3, A4, _1)
#define FEI_4A_8(WHAT, A1, A2, A3, A4, _0, _1, _2) FEI_4A_7(WHAT, A1, A2, A3, A4, _0, _1) WHAT(2, A1, A2, A3, A4, _2)
#define FEI_4A_9(WHAT, A1, A2, A3, A4, _0, _1, _2, _3) FEI_4A_8(WHAT, A1, A2, A3, A4, _0, _1, _2) WHAT(3, A1, A2, A3, A4, _3)
Это (регулярно структурированные разделы) групп макроперегрузок, которые используются для генерации макросов FOR_EACH (aka FE), которые могут отправлять макрос WHAT произвольно с произвольным числом постоянных аргументов (A1, A2...) в дополнение к произвольному числу аргументов в списке вместе с индексом в правильном порядке (наивная реализация без использования чего-то вроде SELECT для перегрузки приведет к обратным индексам).
В качестве примера, оставшаяся часть (нерегулярная часть "базового случая" второго блока) выглядит следующим образом:
#define FE_INDEXED_1ARG(...) VA_SELECT(FEI_1A, __VA_ARGS__)
#define FEI_1A_3(WHAT, A1, _0) WHAT(0, A1, _0)
Полезность этого, возможно, может быть поставлена под сомнение (я построил ее, потому что я видел ее для использования...), и это тоже не отвечает прямо на вопрос ОП (на самом деле это похоже на противоположное - конструкция foreach делает ту же вещь для всех вариационных аргументов...), но я просто подумал, что эта техника довольно интересна (а также совершенно ужасает в некотором роде) и позволяет довольно выразительную силу используя препроцессор, и таким образом можно будет генерировать очень эффективный машинный код. Я думаю, что это также служит убедительным примером того, почему я лично считаю, что препроцессор C все еще имеет возможности для улучшения.
Под этим я подразумеваю, что препроцессор C является абсолютной мерзостью, и мы должны, вероятно, отказаться от него и начать с нуля:)
Ответ 3
Ниже приведено улучшение ответа Potatoswatter, которое может различать нуль и один аргумент.
В двух словах, когда __VA_ARGS__ пуст, макрос EXPAND __VA_ARGS__ () внутри VA_SIZE становится EXPAND () и заменяется на 6 запятых. Итак, VA_SIZE... становится COMPOSE( GET_COUNT, (,,,,,, , 0, 6, 5, 4, 3, 2, 1) ) и становится GET_COUNT (,,,,,, , 0, 6, 5, 4, 3, 2, 1) и возвращает 0.
С другой стороны, когда __VA_ARGS__, например, int, 5, EXPAND __VA_ARGS__ () становится EXPAND int, 5 (). Таким образом, VA_SIZE... становится COMPOSE( GET_COUNT, (EXPAND int, 5 (), 0, 6, 5, 4, 3, 2, 1) ), который становится GET_COUNT (EXPAND int, 5 (), 0, 6, 5, 4, 3, 2, 1) и возвращает 2, как описано в ответе Potatoswatter.
Я получил идею EXPAND от Джейсона Данга.
Код библиотеки:
#define CAT( A, B ) A ## B
#define SELECT( NAME, NUM ) CAT( NAME ## _, NUM )
#define COMPOSE( NAME, ARGS ) NAME ARGS
#define GET_COUNT( _0, _1, _2, _3, _4, _5, _6 /* ad nauseam */, COUNT, ... ) COUNT
#define EXPAND() ,,,,,, // 6 commas (or 7 empty tokens)
#define VA_SIZE( ... ) COMPOSE( GET_COUNT, (EXPAND __VA_ARGS__ (), 0, 6, 5, 4, 3, 2, 1) )
#define VA_SELECT( NAME, ... ) SELECT( NAME, VA_SIZE(__VA_ARGS__) )(__VA_ARGS__)
Использование:
#define MY_OVERLOADED( ... ) VA_SELECT( MY_OVERLOADED, __VA_ARGS__ )
#define MY_OVERLOADED_0( ) meh()
#define MY_OVERLOADED_1( X ) foo< X >
#define MY_OVERLOADED_2( X, Y ) bar< X >( Y )
#define MY_OVERLOADED_3( X, Y, Z ) bang_ ## X< Y >.Z()
MY_OVERLOADED() // meh()
MY_OVERLOADED(bool) // foo< bool >
MY_OVERLOADED(int, 5) // bar< int >( 5 )
MY_OVERLOADED(me, double, now) // bang_me< double >.now()
Ответ 4
Хотя он уже ответил, я подготовил очень короткую версию. Надеюсь, это поможет.
Реализация
// Variable Argument Macro (VA_MACRO) upto 6 arguments
#define NUM_ARGS_(_1, _2, _3, _4, _5, _6, TOTAL, ...) TOTAL
#define NUM_ARGS(...) NUM_ARGS_(__VA_ARGS__, 6, 5, 4, 3, 2, 1)
#define CONCATE_(X, Y) X##Y // Fixed the double '_' from previous code
#define CONCATE(MACRO, NUMBER) CONCATE_(MACRO, NUMBER)
#define VA_MACRO(MACRO, ...) CONCATE(MACRO, NUM_ARGS(__VA_ARGS__))(__VA_ARGS__)
Настройка
// This is how user may define own set of variadic macros
#define MY_MACRO(...) VA_MACRO(MY_MACRO, __VA_ARGS__)
#define MY_MACRO1(_1) "One"
#define MY_MACRO2(_1, _2) "Two"
#define MY_MACRO3(_1, _2, _3) "Three"
Использование
// While using those, user needs to use only the main macro
int main ()
{
auto one = MY_MACRO(1);
auto two = MY_MACRO(1, 2);
auto three = MY_MACRO(1, 2, 3);
}
Ответ 5
Я расширил решение от Potatowater, чтобы избежать необходимости использования iso c99 requires rest arguments to be used переключателя компилятора gcc -pedantic.
Библиотека
#define NUM_ARGS_(_1, _2, _3, _4, _5, _6, _7, _8, TOTAL, ...) TOTAL
#define NUM_ARGS(...) NUM_ARGS_(__VA_ARGS__, 6, 5, 4, 3, 2, 1, 0)
#define CONCATE_(X, Y) X##Y
#define CONCATE(MACRO, NUMBER) CONCATE_(MACRO, NUMBER)
#define VA_MACRO(MACRO, ...) CONCATE(MACRO, NUM_ARGS (__VA_ARGS__))(__VA_ARGS__)
настройка
#define MY_OVERLOADED(...) VA_MACRO(MY_OVERLOADED, void, void, __VA_ARGS__)
#define MY_OVERLOADED0(s, t) MacroTest()
#define MY_OVERLOADED1(s, t, a) MacroTest( a)
#define MY_OVERLOADED2(s, t, a, b) MacroTest(a, b)
#define MY_OVERLOADED3(s, t, a, b, c) MacroTest(a, b, c)
использование
MY_OVERLOADED();
MY_OVERLOADED(1);
MY_OVERLOADED(11, 22);
MY_OVERLOADED(111, 222, 333);