Variadic рекурсивные макросы препроцессора - возможно ли это?

StackOverflow https://stackoverflow.com/questions/824639

  •  05-07-2019
  •  | 
  •  

Вопрос

Я столкнулся с небольшой теоретической проблемой. В части кода, которую я поддерживаю, есть набор макросов, таких как 

#define MAX_OF_2(a, b)       (a) > (b) ? (a) : (b)
#define MAX_OF_3(a, b, c)    MAX_OF_2(MAX_OF_2(a, b), c)
#define MAX_OF_4(a, b, c, d) MAX_OF_2(MAX_OF_3(a, b, c), d)
...etc up to MAX_OF_8

Я хотел бы заменить их на что-то вроде этого: 

/* Base case #1, single input */
#define MAX_OF_N(x)      (x)

/* Base case #2, two inputs */
#define MAX_OF_N(x, y)   (x) > (y) ? (x) : (y)

/* Recursive definition, arbitrary number of inputs */
#define MAX_OF_N(x, ...) MAX_OF_N(x, MAX_OF_N(__VA_ARGS__))

... что, конечно, не является допустимым кодом препроцессора.

Не обращая внимания на то, что этот конкретный случай, вероятно, должен решаться с использованием функции, а не макроса препроцессора , возможно ли определить переменный макрос MAX_OF_N ()?

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

Это было полезно?

Решение

Нет, потому что препроцессор берет только один "удар" в файле. Нет способа заставить его рекурсивно определять макросы.

Единственный код, который я видел, выполнял что-то вроде этого, это not variadic, но использовал значения по умолчанию, которые пользователь должен был передать: 

x = MAX_OF_8 (a, b, -1, -1, -1, -1, -1, -1)

при условии, что все значения были неотрицательными.

Встроенные функции должны дать вам то же самое для C ++, по крайней мере. Как вы заявляете, вероятно, лучше оставить функцию с переменными аргументами, похожими на printf () .

Другие советы

Можно написать макрос, который оценивает количество аргументов, с которыми он вызывается. (Я не смог найти ссылку на место, где я впервые ее увидел.) Таким образом, вы можете написать MAX_OF_N (), который будет работать так, как вам хочется, но вам все равно понадобятся все пронумерованные макросы до некоторого предела: 

#define MAX_OF_1(a)         (a)         
#define MAX_OF_2(a,b)       max(a, b)

#define MAX_OF_3(a,...)    MAX_OF_2(a,MAX_OF_2(__VA_ARGS__))
#define MAX_OF_4(a,...)    MAX_OF_2(a,MAX_OF_3(__VA_ARGS__))
#define MAX_OF_5(a,...)    MAX_OF_2(a,MAX_OF_4(__VA_ARGS__))
...
#define MAX_OF_64(a,...)   MAX_OF_2(a,MAX_OF_63(__VA_ARGS__))

// NUM_ARGS(...) evaluates to the literal number of the passed-in arguments.
#define _NUM_ARGS2(X,X64,X63,X62,X61,X60,X59,X58,X57,X56,X55,X54,X53,X52,X51,X50,X49,X48,X47,X46,X45,X44,X43,X42,X41,X40,X39,X38,X37,X36,X35,X34,X33,X32,X31,X30,X29,X28,X27,X26,X25,X24,X23,X22,X21,X20,X19,X18,X17,X16,X15,X14,X13,X12,X11,X10,X9,X8,X7,X6,X5,X4,X3,X2,X1,N,...) N
#define NUM_ARGS(...) _NUM_ARGS2(0, __VA_ARGS__ ,64,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)

#define _MAX_OF_N3(N, ...) MAX_OF_ ## N(__VA_ARGS__)
#define _MAX_OF_N2(N, ...) _MAX_OF_N3(N, __VA_ARGS__)
#define MAX_OF_N(...)      _MAX_OF_N2(NUM_ARGS(__VA_ARGS__), __VA_ARGS__)

Теперь MAX_OF_N (a, b, c, d, e) оценивается как max (a, max (b, max (c, max (d, e))))) . (Я тестировал на gcc 4.2.1.)

Обратите внимание, что очень важно, чтобы базовый случай ( MAX_OF_2 ) не повторял свои аргументы более одного раза в расширении (именно поэтому я поместил max в этом примере ). В противном случае вы бы удвоили длину расширения для каждого уровня, поэтому вы можете представить, что произойдет с 64 аргументами:)

Вы можете рассмотреть этот обман, так как он не является рекурсивным и не выполняет работу в препроцессоре. И он использует расширение GCC. И это работает только для одного типа. Это, однако, вариационный макрос MAX_OF_N: 

#include <iostream>
#include <algorithm>

#define MAX_OF_N(...) ({\
        int ra[] = { __VA_ARGS__ }; \
        *std::max_element(&ra[0], &ra[sizeof(ra)/sizeof(int)]); \
    })

int main() {
    int i = 12;
    std::cout << MAX_OF_N(1,3,i,6);
}

О да, и из-за потенциального выражения переменной в списке инициализатора, я не думаю, что эквивалент этого (использование его собственной функции, чтобы избежать std :: max_element) сработал бы в C89. Но я не уверен, что в C89 также есть переменные макросы.

Вот кое-что, что, я думаю, обходит «только один тип» ограничение. Это становится немного волосатым, хотя: 

#include <iostream>
#include <algorithm>

#define MAX_OF_N(x, ...) ({\
        typeof(x) ra[] = { (x), __VA_ARGS__ }; \
        *std::max_element(&ra[0], &ra[sizeof(ra)/sizeof(ra[0])]); \
    })

int main() {
    int i = 12;
    std::cout << MAX_OF_N(i+1,1,3,6,i);
}

Я думаю, что даже если бы вы могли рекурсивно расширять макросы, с вашим подходом с точки зрения эффективности возникла бы одна маленькая проблема ... когда макросы раскрываются, если MAX_OF_ [N-1] больше, то вам придется снова оценить его с нуля.

Вот глупый и глупый ответ, который, вероятно, никому не понравится xD

файл " source.c " 

#include "my_macros.h"
...

file " Makefile " 

myprogram: source.c my_macros.h
 gcc source.c -o myprogram

my_macros.h: make_macros.py
 python make_macros.py > my_macros.h

файл " make_macros.py " 

def split(l):
    n = len(l)
    return l[:n/2], l[n/2:]

def gen_param_seq(n):
    return [chr(i + ord("A")) for i in range(n)]

def make_max(a, b):
    if len(a) == 1:
        parta = "("+a[0]+")"
    else:
        parta = make_max(*split(a))

    if len(b) == 1:
        partb = "("+b[0]+")"
    else:
        partb = make_max(*split(b))

    return "("+parta +">"+partb+"?"+parta+":"+partb+")"

for i in range(2, 9):
    p = gen_param_seq(i)
    print "#define MAX_"+str(i)+"("+", ".join(p)+") "+make_max(*split(p))

тогда у вас будут определены эти красивые макросы: 

#define MAX_2(A, B) ((A)>(B)?(A):(B))
#define MAX_3(A, B, C) ((A)>((B)>(C)?(B):(C))?(A):((B)>(C)?(B):(C)))
#define MAX_4(A, B, C, D) (((A)>(B)?(A):(B))>((C)>(D)?(C):(D))?((A)>(B)?(A):(B)):((C)>(D)?(C):(D)))
#define MAX_5(A, B, C, D, E) (((A)>(B)?(A):(B))>((C)>((D)>(E)?(D):(E))?(C):((D)>(E)?(D):(E)))?((A)>(B)?(A):(B)):((C)>((D)>(E)?(D):(E))?(C):((D)>(E)?(D):(E))))
#define MAX_6(A, B, C, D, E, F) (((A)>((B)>(C)?(B):(C))?(A):((B)>(C)?(B):(C)))>((D)>((E)>(F)?(E):(F))?(D):((E)>(F)?(E):(F)))?((A)>((B)>(C)?(B):(C))?(A):((B)>(C)?(B):(C))):((D)>((E)>(F)?(E):(F))?(D):((E)>(F)?(E):(F))))
#define MAX_7(A, B, C, D, E, F, G) (((A)>((B)>(C)?(B):(C))?(A):((B)>(C)?(B):(C)))>(((D)>(E)?(D):(E))>((F)>(G)?(F):(G))?((D)>(E)?(D):(E)):((F)>(G)?(F):(G)))?((A)>((B)>(C)?(B):(C))?(A):((B)>(C)?(B):(C))):(((D)>(E)?(D):(E))>((F)>(G)?(F):(G))?((D)>(E)?(D):(E)):((F)>(G)?(F):(G))))
#define MAX_8(A, B, C, D, E, F, G, H) ((((A)>(B)?(A):(B))>((C)>(D)?(C):(D))?((A)>(B)?(A):(B)):((C)>(D)?(C):(D)))>(((E)>(F)?(E):(F))>((G)>(H)?(G):(H))?((E)>(F)?(E):(F)):((G)>(H)?(G):(H)))?(((A)>(B)?(A):(B))>((C)>(D)?(C):(D))?((A)>(B)?(A):(B)):((C)>(D)?(C):(D))):(((E)>(F)?(E):(F))>((G)>(H)?(G):(H))?((E)>(F)?(E):(F)):((G)>(H)?(G):(H))))

и самое лучшее в этом то, что ... это работает ^ _ ^

Если вы идете по этому пути в C ++, взгляните на шаблонное метапрограммирование . Это не красиво, и это может не решить вашу проблему, но она справится с рекурсией.

Во-первых, макросы не расширяются рекурсивно. Хотя макросы могут иметь вход, создавая макрос для каждого уровня рекурсии, а затем определяя уровень рекурсии. Однако обо всех этих повторениях и выводных рекурсиях заботится . Поэтому вы можете использовать макрос сгиба более высокого порядка для вычисления максимального значения: 

#define MAX_EACH(s, x, y) BOOST_PP_IF(BOOST_PP_GREATER_EQUAL(x, y), x, y)
#define MAX(...) BOOST_PP_SEQ_FOLD_LEFT(MAX_EACH, 0, BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__)) 

MAX(3, 6, 8) //Outputs 8
MAX(4, 5, 9, 2) //Outputs 9

Теперь, это будет понимать буквальные числа между 0-256. Он не будет работать с переменными или выражениями C ++, потому что препроцессор C не понимает C ++. Это просто замена текста. Но C ++ предоставляет функцию под названием «функция» это будет работать с выражениями C ++, и вы можете использовать его для вычисления максимального значения. 

template<class T>
T max(T x, T y)
{
    return x > y ? x : y;
}

template<class X, class... T>
auto max(X x, T ... args) -> decltype(max(x, max(args...)))
{
    return max(x, max(args...));
}

Теперь приведенный выше код требует компилятора C ++ 11. Если вы используете C ++ 03, вы можете создать несколько перегрузок функции для симуляции переменных параметров. Кроме того, мы можем использовать препроцессор для генерации этого повторяющегося кода для нас (вот для чего он нужен). Так что в C ++ 03 вы можете написать это: 

template<class T>
T max(T x, T y)
{
    return x > y ? x : y;
}

#define MAX_FUNCTION(z, n, data) \
template<class T> \
T max(T x, BOOST_PP_ENUM_PARAMS(n, T x)) \
{ \
    return max(x, max(BOOST_PP_ENUM_PARAMS(n, x)));\
}

BOOST_PP_REPEAT_FROM_TO(2, 64, MAX_FUNCTION, ~)
Не связан с StackOverflow
scroll top