Variadic recursive preprocessor macros – is it possible?

by

It’s possible to write a macro that evaluates to the number of arguments it’s called with. (I couldn’t find a link to the place where I first saw it.) So you could write MAX_OF_N() that would work as you’d like, but you’d still need all the numbered macros up until some limit:

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

Now MAX_OF_N(a,b,c,d,e) will evaluate to max(a, max(b, max(c, max(d, e)))). (I’ve tested on gcc 4.2.1.)

Note that it’s critical that the base case (MAX_OF_2) doesn’t repeat its arguments more than once in the expansion (which is why I put max in this example). Otherwise, you’d be doubling the length of the expansion for every level, so you can imagine what will happen with 64 arguments 🙂

More Related Contents:

  1. How can I generate unique values in the C preprocessor?
  2. How do I show the value of a #define at compile-time?
  3. Overloading Macro on Number of Arguments
  4. C macros and use of arguments in parentheses
  5. Can we have recursive macros?
  6. What exactly do C include guards do?
  7. Array-size macro that rejects pointers
  8. Is it possible to declare variables procedurally using Rust macros?
  9. Can a Rust macro create new identifiers?
  10. What makes Lisp macros so special?
  11. Macros in Swift?
  12. How to prefix/suffix identifiers within a macro? [duplicate]
  13. How to identify platform/compiler from preprocessor macros?
  14. Escaping a # symbol in a #define macro?
  15. What are C macros useful for?
  16. Opposite of C preprocessor “stringification”
  17. How do I match the type of an expression in a Rust macro?
  18. macro definition containing #include directive
  19. C Macros to create strings
  20. Macro and function with same name
  21. C# Macro definitions in Preprocessor
  22. Can macros match against constant arguments instead of literals?
  23. How to allow optional trailing commas in macros?
  24. Confused by squaring macro SQR in c [duplicate]
  25. How to write macro for Notepad++?
  26. How to tame the Windows headers (useful defines)?
  27. Mathematica: Unevaluated vs Defer vs Hold vs HoldForm vs HoldAllComplete vs etc etc
  28. How to embed a Rust macro variable into documentation?
  29. offsetof at compile time
  30. Macros to create strings in C

Leave a Comment