C Macros
Let’s say you have a program that works with arrays of a certain size: say, 100 elements. The number 100 will show up in different parts of the code:
float stuff[100];
// ... elsewhere ...
for (int i = 0; i < 100; ++i) {
do_something(stuff[i]);
}
Repeating the number 100 in multiple locations is not great for multiple reasons:
- It is not maintainable. If you ever need to change the size of the array, you need to carefully look for all the places where you mentioned 100 and change it to something else. If you happen to miss one, subtle bugs will arise.
- It is not readable. Writing code is as much about communicating with other programmers as it is about communicating with the machine! When a human sees the number 100 appear out of nowhere, it can be mysterious and worrisome. For this reason, programmers often call these arbitrary-seeming constants magic numbers (in a derogatory way).
C has a feature called the preprocessor that can cut down on duplication, eliminate magic numbers, and make code more readable. In particular, you can use a macro definition to give your constant a name:
#define NUMBER_OF_THINGS 100
The syntax #define <macro> <expression> defines a new name, the macro, and instructs the preprocessor to replace that name with the given expression.
(Notably, there is no semicolon after preprocessor directives like #define.)
It is a convention to always use SHOUTY_SNAKE_CASE for macro names to help visually distinguish them from ordinary C variable names.
In this example, the C preprocessor will “find and replace” all occurrences of NUMBER_OF_THINGS in our program and replace it with the expression 100.
So it means exactly the same thing to rewrite our program above like this:
#define NUMBER_OF_THINGS 100
float stuff[NUMBER_OF_THINGS];
// ... elsewhere ...
for (int i = 0; i < NUMBER_OF_THINGS; ++i) {
do_something(stuff[i]);
}
The C preprocessor runs before the actual compiler, so you can think of it as doing a textual “find and replace” operation before compiling your code.