macros - preprocessore - macro in c




Macro del preprocessore ricorsivo variadico-è possibile? (4)

Ho incontrato un piccolo problema teorico. In un pezzo di codice sto mantenendo un insieme di macro come

#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

Quello che mi piacerebbe fare è sostituirli con qualcosa del genere:

/* 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__))

... che, ovviamente, non è un codice di preprocessore valido.

Ignorando che questo caso particolare dovrebbe probabilmente essere risolto utilizzando una funzione piuttosto che una macro del preprocessore , è possibile definire una macro MAX_OF_N () variadica?

Solo per chiarezza, il risultato finale dovrebbe essere una singola macro che prende un numero arbitrario di parametri e valuta il più grande di essi. Ho la strana sensazione che questo dovrebbe essere possibile, ma non vedo come.


È possibile scrivere una macro che valuti il ​​numero di argomenti con cui è chiamato. (Non sono riuscito a trovare un collegamento al luogo in cui l'ho visto per la prima volta.) Quindi potresti scrivere MAX_OF_N () che funzionerebbe come vorresti, ma avresti comunque bisogno di tutti i macro numerati fino a un certo limite:

#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__)

Ora MAX_OF_N(a,b,c,d,e) valuterà a max(a, max(b, max(c, max(d, e)))) . (Ho provato su gcc 4.2.1.)

Si noti che è fondamentale che il caso base ( MAX_OF_2 ) non ripeta i suoi argomenti più di una volta nell'espansione (che è il motivo per cui metto max in questo esempio). Altrimenti, raddoppierai la durata dell'espansione per ogni livello, quindi puoi immaginare cosa succederà con 64 argomenti :)


Innanzitutto, le macro non si espandono in modo recusivo. Sebbene, i macro possano avere rientranza creando una macro per ciascun livello di ricorsione e quindi deducendo il livello di ricorsione. Tuttavia, tutta questa ripetizione e deduzione della ricorsione viene Boost.Preprocessor libreria Boost.Preprocessor . È quindi possibile utilizzare la macro di ordine più frequente per calcolare il massimo:

#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

Ora, questo comprenderà i numeri letterali tra 0-256. Non funzionerà su variabili o espressioni C ++, perché il preprocessore C non capisce C ++. È una sostituzione puramente testuale. Ma C ++ fornisce una funzionalità chiamata "funzione" che funzionerà su espressioni C ++, e puoi usarla per calcolare il valore massimo.

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...));
}

Ora, il codice sopra richiede un compilatore C ++ 11. Se si utilizza C ++ 03, è possibile creare sovraccarichi multipli della funzione per simulare i parametri variadici. Inoltre, possiamo usare il preprocessore per generare questo codice ripetitivo per noi (questo è quello che è lì per). Quindi in C ++ 03, puoi scrivere questo:

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, ~) 

Penso che, anche se fosse possibile espandere le macro in modo ricorsivo, ci sarebbe un piccolo problema con il tuo approccio in termini di efficienza ... quando le macro sono espanse, se MAX_OF_[N-1] è maggiore, devi valutare di nuovo da zero.

Ecco una risposta sciocca e stupida che probabilmente a nessuno piacerà xD

file "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

file "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))

allora avrai definito quelle macro carine:

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

e la cosa migliore è che ... funziona ^ _ ^


Se stai seguendo questa strada in C ++, dai un'occhiata al metaprogramma dei modelli . Non è carino e potrebbe non risolvere il tuo problema esatto, ma gestirà la ricorsione.