Question

Define a macro MAX3 that gives the maximum of three values.

This is what I came up with:

#define MAX3(a,b,c) ( ((a) > (b)) && ((a) > (c)) ) ? (a) : ((b) > (c)) ? (b) : (c)

This is hard to read. Is there a way to write an equivalent macro with if–else statements?

Answer 1

Having an expression-like macro with statements inside is not possible in standard C99 language (because in C99 statements and expressions are deeply different, both syntactically and semantically).

However, GCC (and some other compilers with extensions inspired by GCC, e.g. clang) provides a nice extension for that : statement expressions (the documentation gives an example related to your question). With that extension you could code something like

 #define MAX3(A,B,C) ({ int a=(A); int b=(B); int c=(C); int m; \
     if (a>b) m=a; else m=b;                                    \
     if (c>m) m=c;                                              \
     m; }) /* bad macro */

however that still won’t work if you use that macro like e.g.

 int badex(int x, int y) { 
    int a= x+y; int m= x*y; int d=x-y; 
    return MAX3(a,m,d);
 }

I hope you see why it won’t work (name clashes e.g. between the a inside badex and the a inside MAX3 macro). So you need a way to have unique names at every invocation of your macro. Again, GCC provides a nice extension for that, the __COUNTER__ macro (expanded to a unique number, counting) used with concatenation in the preprocessor.

Then you’ll code something like

 #define MAX3(A,B,C) MAX3_COUNTED((A),(B),(C),__COUNTER__)
 #define MAX3_COUNTED(A,B,C,N)  ({                          \
    int a_##N=(A); int b_##N=(B); int c_##N=(C);            \
    int m_##N;                                              \
    if (a_##N>b_##N) m_##N = a_##N; else m_#N = b_##N;      \
    if (c_##N>m_##N) m_##N=c_##N;                           \
  m_##N; }) /* better example */

Then the first invocation of our macro e.g. MAX3(i++,j++,k++) might expand to MAX3_COUNTED((i++),(j++),(k++),1) which gets expanded into something using a_1 b_1 … and the second invocation, e.g. MAX3(a,m,d) expanded as MAX3_COUNTED((a),(m),(d),2) would use a_2 b_2 etc so is better.

And of course, defining a static inline max3(int a, int b, int c) function is cleaner (in particular because of side effects: your MAX3 macro gives naughty effects and results with a call like MAX3(i++,j++,k++) etc)

The general lesson about this is that you should when possible avoid macro (preferring inline functions), and when you absolutely need macros take care about name clashes and expansions.

Using GCC invoked as gcc -C -E shows you the preprocessed form of your program.