The C Pre-Processor, Continued

CPP Review

The C Pre-processor does textual manipulation of a C file.
- #include directives.
- #if and #ifdef directives.
- Macros and constants (with #define and sometimes with #undef)
- ...
Can invoke with cc -E or cpp.

Macros: Review

#define MACRO(PARAMS) REPLACEMENT
Each time a formal parameter appears in the replacement, it gets replaced by the corresponding actual.

E.g.,

#define SUM(X,Y) X+Y
printf ("%d\n", SUM(2,3));

Gets rewritten as
```
  printf ("%d\n", 2+3);
```

Modern C preprocessor (particularly the GCC CPP) allow some awesome special forms.
- #PARAM gives the parameter as a C string.
- FOO ## BAR concatenates FOO and BAR.

An Extended Example: Code Templates

Goal: Write the find the minimum algorithm once (for all types).
Strategy: Factor out the type-specific parts
- Prefix for the function name
- Type of the parameter
- Comparator (although this could also be a parameter)
Code in Examples/Min1
Of course, refactoring might also suggest that we make the comparator a parameter (so we can do "closest to zero" or "largest" or other maxima/minima thing).
Code in Examples/Min2
What are other instances in which code templates might be useful?

Macros vs. Functions, Revisited

We've seen that macros can behave similarly to functions.
E.g.,
- #define IMAX(A,B) A > ? B : A
- int imax(A,B) { return A > ? B : A
We've seen that macros are likely to be faster
- No function call overhead!
- Compiler might be able to simplify.
So why not use macros?
- ...
An alternative? Inline the code!
- inline int max(A,B) { ... };

Multi-Line and Multi-Step Macros

If we're going to use macros instead of functions, we probably need to think about two things.
- How can we write multiple lines?
- How can we write multiple instructions?
Multiple lines are easy. You can just put in a backslash at the end of the line.
Multiple instructions are complicated.
- Why is it complicated? We need to worry about extra semicolons.
- Consider while (1) FOO(BAR,BAZ);
- If FOO expands to something with a semicolon, only the first statement will get executed.
- See Examples/loop.c
The typical form of the solution - put it into a one-iteration do-while loop.
```
#define STUFF(A,B) do { printf ("%s", A); printf ("s", B); } while (0)
```

Sam likes to use

#define BOX(CODE) do { CODE } while (0)
#define STUFF(A,B) BOX( \
                        printf ("%s", A); \
                        printf ("%s", B); \
                      )

Testing and Experiments

Good programmers test.
- When test harnesses don't exist, good programmers build simple test harnesses.
Good programmers may also experiment.

Helpful macros for testing

#define ITEST(EXP,EXPECTED) \
  BOX ( \
        int result = EXP; \
        ++__tests_conducted; \
        if (result != EXPECTED) \
          { \
            ++__tests_failed; \
            printf ("%s failed.  Got %d, expected %d.\n", \
                    #EXP, result, EXPECTED);
          } \
      )

For experiments, I find the following useful:

#define EXPERIMENT(CODE) BOX ( printf ("    %s;\n", #CODE); CODE; )

Two additional helpful macros
- __FILE__, the name of the current file
- __LINE__, the number of the current line

So ....

#define EXPERIMENT(CODE) BOX ( printf ("    %s.%03d: %s;\n", __FILE__, __LINE__, #CODE); CODE; )