The C Preprocessor: Macros and Conditional Compilation

Hello students, welcome to Kwickprep. What is two plus three, squared? Twenty five, of course. But one small C macro can print eleven instead. Today we will learn what happens to your program before the compiler even sees it. We will cover include, define, macros with arguments, and conditional compilation, and we will solve the eleven mystery.

Here is the journey of a C program. It begins as a source file, the code you type, like prog dot c. First, the preprocessor reads it and makes text changes. Then the compiler turns that changed code into machine code. Then the linker joins it with library code, such as printf. The result is a program you can run.

The preprocessor is a tool that edits your code as text, before compiling. It handles lines that start with a hash sign, called directives, which are instructions to the preprocessor. It pastes the contents of header files into your code. It replaces each macro name with its text. It removes comments, since the compiler does not need them. And it can keep or drop parts of the code based on conditions.

The include directive copies a whole header file into your program. A header file, ending in dot h, holds declarations of functions and constants. With angle brackets, the preprocessor searches the system folders, so we use it for library headers like stdio dot h. With double quotes, it searches your project folder first, so we use it for headers we write ourselves.

The define directive creates a macro, which is a name that stands for some text. Here PI stands for three point one four, and SEATS stands for forty, the seats in a classroom. Before compiling, every PI is replaced with three point one four. So PI times two becomes three point one four times two. It prints six point two eight and forty.

Follow these rules for define. Write no equals sign and no semicolon, because the semicolon would be pasted into your code too. By convention, macro names are written in capital letters, so they stand out. A macro is pure text replacement, so it has no data type and uses no memory as a variable. The big benefit is that you change the value in one place, and the whole program updates.

A macro can take arguments, like a small function. SQUARE of x becomes x times x, so SQUARE of four gives sixteen. MAX of a and b uses the conditional operator, a question mark and a colon. It means, if a is greater than b, pick a, otherwise pick b. So MAX of seven and nine gives nine. Notice there is no space between the macro name and the opening bracket.

Now the mystery from the start. Pause the video and predict what this prints. Most students say twenty five, but it prints eleven. The macro pastes text without brackets, so it becomes two plus three times two plus three. Multiplication happens first, so three times two is six, and two plus six plus three is eleven. That is why we put brackets around every argument, and around the whole macro.

Exams often ask how a macro differs from a function. A macro is handled by the preprocessor, but a function is handled by the compiler. A macro has no type checking, while a function checks the types of its arguments. A macro has no call overhead, which means no time spent jumping to a function and back. But macros can fall into the brackets trap we just saw, and functions cannot.

Conditional compilation means the preprocessor keeps or removes code based on a condition. Here DEBUG is defined, with no value. The directive if def asks, is DEBUG defined? Yes, so the line Checking marks is kept. If we delete the define line, that printf is removed before compiling, as if we never wrote it. Programmers use this to switch extra checking messages on and off.

The if directive works like an if statement, but it runs before compiling. It can only test constant values, such as a macro. MARKS is forty, which is thirty three or more. So RESULT is defined as Pass, and the else part is thrown away. Every if block must be closed with end if.

Here are the conditional directives in one table. Hash if and hash elif keep code when a constant condition is true. Hash if def keeps code when a name is defined. Hash if n def keeps code when a name is not defined, and it is used in header guards. Hash undef removes a macro, so the name is no longer defined.

If a header file is included twice, the compiler may complain about repeated definitions. A header guard stops this. The first time, MARKS underscore H is not defined, so the code is kept and the name gets defined. The second time, the name already exists, so everything up to end if is skipped.

Let us revise what we learned today. The preprocessor edits your code as text before the compiler runs. Include pastes a header file into your program. Define makes a macro, with no equals sign and no semicolon. Always put brackets around macro arguments, or you may get eleven instead of twenty five. And if, if def and if n def keep or drop code before compiling.