Table of Contents

C Pre-Processor Magic

The C Pre-Processor (CPP) is the somewhat basic macro system used by the C programming language to implement features such as #include and #define which allow very simple text-substitutions to be carried out at compile time. In this article we abuse the humble #define to implement if-statements and iteration.

Before we begin, a disclaimer: these tricks, while perfectly valid C, should not be considered good development practice and should almost certainly not be used for "real work". That said it can totally be used for fun home-automation projects... Finally, whilst these tricks have been found to work under GCC and Clang's CPP implementations, I've heard that they might not under Microsoft's compilers.

The humble #define

Most C programmers will be familiar with the common-or-garden #define preprocessor directive. This directive allows the programmer to define a simple text-substitution macro. For example:

#define VERSION 123

// ... later ...
printf("Version: %d\n", VERSION);

In this snippet we define a macro VERSION which the CPP will look for and replace with 123. We can specify any valid sequence of C tokens (that is, fragments of valid C though these need not be syntactically valid, for example , 123 { hello would be acceptable). We can see this in action by feeding this to CPP like so:

cpp << EOF
#define VERSION 123

// ... later ...
printf("Version: %d\n", VERSION);
EOF

Which produces:

# 1 "<stdin>"
# 1 "<built-in>"
# 1 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 1 "<command-line>" 2
# 1 "<stdin>"



printf("Version: %d\n", 123);

This is actually the raw input that your compiler sees and compiles. The lines starting with # are not preprocessor directives but rather compiler hints which help the compiler work out line-numbers after #includes have been added and comments removed and thus produce helpful error messages. You can suppress these lines using -P.

We can also define 'function-style' macros which take a number of arguments:

#define MULTIPLY(a, b) a * b

// ... later ...

printf("4*8 = %d\n", MULTIPLY(4, 8));

Which expands to:

printf("4*8 = %d\n", 4 * 8);

Note that when using these in normal code it is common to place brackets around the macro substitution and also around the arguments:

#define MULTIPLY(a, b) ((a) * (b))

The reason for this is that without the brackets the following may not do what you'd expect:

printf("%d\n", MULTIPLY(4 + 2, 2 + 8) * 2);

Without brackets this expands to:

printf("%d\n", 4 + 2 * 2 + 8 * 2);

Which due to operator precedence rules (multiplies are evaluated first) would not evaluate how you'd expect. The bracketed version, however, works as you'd expect:

printf("%d\n", ((4 + 2) * (2 + 8)) * 2);

As a final advanced twist, we can define function style macros with varadic arguments. You'll see these most often looking like this:

#define DEBUG(...) fprintf(stderr, __VA_ARGS__)

// ... later, inside a for-loop ...

DEBUG("Something went wrong in iteration: %d", i);

If we specify the final argument to our macro as being ..., the macro will accept any number of arguments (even zero). These arguments are inserted into your substitution if you write __VA_ARGS__, complete with separating commas between each of the arguments.

This is where sane usage of macros in C ends.

If-statements

Time for our first bit of magic. Let's try and produce a macro that does the following:

IF_ELSE(condition)(
    expand to this if condition is not 0
)(
    expand to this otherwise
)

Unlike a C if-else-statement, the condition will be evaluated in the preprocessor, before your code is even compiled. The usefulness of this will become more apparent later on.

Pattern Matching

The key to our if-else statement is abusing CPP to perform pattern matching like so:

#define IF_ELSE(condition) _IF_ ## condition
#define _IF_1(...) __VA_ARGS__ _IF_1_ELSE
#define _IF_0(...)             _IF_0_ELSE

#define _IF_1_ELSE(...)
#define _IF_0_ELSE(...) __VA_ARGS__

Download & Try Me! (Hint: cpp -P filename.txt)

First notice that IF_ELSE takes a single argument: a condition. In our example above you can see that this is then followed by two parenthesised expressions corresponding to the true and false case for the condition respectively.

Lets see how this works in practice by walking through the expansion of the 1 and 0 cases:

Condition is 1 case:
- IF_ELSE(1)(it was one)(it was zero)
- _IF_ ## 1 (it was one)(it was zero)
- _IF_1 (it was one)(it was zero)
- it was one _IF_1_ELSE (it was zero)
- it was one
Condition is 0 case:
- IF_ELSE(0)(it was one)(it was zero)
- _IF_ ## 0 (it was one)(it was zero)
- _IF_0 (it was one)(it was zero)
- _IF_0_ELSE (it was zero)
- it was zero

The trick here is using the CPP concatenation operator (##) to concatenate _IF_ and the condition argument. In this case we expect condition to be either 0 or 1 and so the result is either _IF_1 or _IF_0. These two macros combine with the second set of brackets (the true clause) and either reproduce their arguments or swallow them respectively. They also produce a matching _IF_1_ELSE or _IF_0_ELSE macro which combines with the third set of brackets, swallowing or reproducing the arguments respectively.

Cast to bool!! (and negation)

Our IF_ELSE is looking pretty good at this point but what if we write:

IF_ELSE(123)(non-zero)(zero)

C Pre-Processor Magic

The humble #define

If-statements

Pattern Matching

Cast to bool!! (and negation)

Iterators

Forcing CPP to make multiple passes

Turning multiple expansion passes into recursion

Turning recursion into an iterator

Learning More