The loss of the # character to the preprocessor is a minor blow, requiring C to define a new comment syntax.

Avoid #ifdef and its ilk. Conditional compilation is the most egregious preprocessor evil, as it obfuscates code for humans and automated tools alike. Tweaking compilation is a task best left for the build system. For example, code specific to particular architectures should be placed in separate files; the build system should choose which is appropriate.

A close second is misuse of the #define directive. Never use macros to define functions. They can cause mysterious bugs due to side effects from insufficient insulation, and make the code harder to analyze by human or machine. Moreover, they are unnecessary now that C99 supports the inline keyword (in header files, simply declare the function to be static inline).

There are times where textual substitution makes sense, and #define is appropriate. Kernighan and Pike’s example is:

#define NELEM(a) (sizeof(a)/sizeof(a[0]))

which returns the size of a static array, a macro so useful that there should have been a keyword or operator for this to begin with.

When used be sure a macro is truly warranted; in the above example, observe the quantity is computed at compile time, and no function could take its place.

For programming contests, save typing by defining macros for common tasks such as looping in the interval [0..N-1], and reading and writing integers.

Another application is debugging. We can access the source file name and line number via macros.

#define REP(x, n) for (int x = 0; x < n; x++)
#define REP1(x, n) for (int x = 1; x <= n; x++)
#define EXPECT(condition) \
  if (!(condition)) fprintf(stderr, "%s:%d: FAIL\n", __FILE__, __LINE__)

// Prints the quadratic residues (squares) for a given modulus.
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char **argv) {
  enum { MIN = 2, MAX = 1 << 15 };
  if (2 != argc) return printf("Usage: %s NUMBER\n", *argv), 0;
  int m = atoi(argv[1]);

  // This next line is buggy. The && should be ||.
  if (m < MIN && m > MAX) return printf("Modulus out of range\n"), 0;

  // These lines will catch the bug when the argument is out of range.
  EXPECT(m >= MIN);
  EXPECT(m <= MAX);
  REP(i, m) printf(" %d", i * i % m);
  puts("");
  return 0;
}

Rather than #define integer constants, use enum, as const int is insufficient. Declaring i as const merely tells the compiler to report errors if code attempts to write to i directly. We can break the rules by casting away the const, but the results are undefined. For example, on Linux, gcc places a static const int in a read-only data segment: attempts to write to it cause segmentation faults.

If our code never touches i, can it ever change? A classic C riddle along the same lines asks if const volatile ever makes sense. Wikipedia has the answer. Unlike enum, the rules prohibit replacing a const variable with a true constant at compile time.

Even so, for other types, a const variable may be preferable to #define constants.

Unfortunately C lacks Java-style packages, so C programmers must use include files. We should follow Rob Pike’s advice: include files should not include files. If there are dependencies, they should be mentioned in comments and it is the .c file’s duty to include them. Also, if we must have header guards, they should be the reverse of common practice: check if you can avoid including a file before including it, not while it’s being included. This saves the preprocessor from churning through thousands of lines.