Exercises — Preprocessor directives — #define, #ifdef, #ifndef, #include guards

• #define MAX 100 → everywhere the token MAX appears later, paste the text 100.
• #ifdef DEBUG → keep the following lines only if DEBUG is currently defined; otherwise delete them.
• #ifndef CONFIG_H → keep the following lines only if CONFIG_H is not defined.
• #endif → close the most recent conditional block.

Directives (start with #, handled before compilation): (a) and (c). Ordinary C statements (handled by the compiler): (b) and (d). The distinguishing mark is the leading #.

Substitute DOUBLE(5) → (5) + (5): $\text{int y = (5) + (5) * 3;}$ Now the compiler applies precedence: * before +, so (5) * 3 = 15, then (5) + 15 = 20. Answer: 20 — not 30. The body wasn't wrapped in outer parentheses, so the * 3 grabbed only the second (x).

Blind substitution → int z = 6 + 4 / 2; Precedence: / before +, so 4 / 2 = 2, then 6 + 2 = 8. Answer: 8 (not 5). The fix is #define HALF(x) ((x) / 2).

Substitute → ((3 + 1) * (3 + 1)) → (4 * 4) = 16. The full parenthesisation makes this behave like a real squaring.

VERBOSE is defined → the printf("A\n"); survives. QUIET is never defined → the #ifdef QUIET block is deleted as text; printf("B\n"); never reaches the compiler. Surviving code: just printf("A\n");. This is the mechanism behind Conditional compilation for cross-platform code.

The replacement text for SIZE is 32; (semicolon included). So int arr[SIZE]; becomes: $\text{int arr[32;];}$ That is not valid C — the ; inside the brackets breaks it. A #define is not a C statement, so it takes no trailing semicolon. Fix: #define SIZE 32.

No — struct B is silently dropped.

1. a.h pasted first: HEADER_H undefined → guard is true → define HEADER_H, keep struct A.
2. b.h pasted next: HEADER_H is now defined → #ifndef HEADER_H is false → the whole body of b.h (including struct B) is deleted. The tag must be unique (e.g. A_H, B_H) — see the include-order picture below.

Exactly once.

• 1st include: POINT_H undefined → guard true → define POINT_H, keep the struct.
• 2nd include: POINT_H now defined → guard false → body deleted. The guard prevents the "redefinition of struct Point" error you'd get without it. See Header files and translation units.

#ifndef MATRIX_UTILS_H
#define MATRIX_UTILS_H
 
struct Matrix { int rows, cols; };
 
#endif /* MATRIX_UTILS_H */

The tag is derived from the filename (uppercase, . → _) so it is unique across the project.

#define MIN(a, b) (((a) < (b)) ? (a) : (b))

Every argument is wrapped, and the whole conditional expression is wrapped. Check with MIN(3+1, 2*5) → (((3+1) < (2*5)) ? (3+1) : (2*5)) → (4 < 10) ? 4 : 10 → 4. (Caveat worth knowing: because a and b are pasted twice, MIN(i++, j) evaluates i++ twice — a reason inline functions are often safer.)

#ifndef LOG_LEVEL
#define LOG_LEVEL 2
#endif

If the build passes -DLOG_LEVEL=4 (see Build flags -D and the command line), then LOG_LEVEL is already defined → the #ifndef is false → the default is skipped and 4 wins. Otherwise it defaults to 2.

Step 1 — LIMIT undefined → guard true → #define LIMIT 10. Step 2 — SCALE is defined → keep the #ifdef SCALE branch, delete the #else. Step 3 — expand macros in int total = AREA(2 + 1, LIMIT) * SCALE;:

• AREA(2 + 1, LIMIT) → ((2 + 1) * (LIMIT)) → ((2 + 1) * (10))
• SCALE → 3 Surviving code: $\text{int total = ((2 + 1) * (10)) * 3;}$ Step 4 — the compiler evaluates: (3 * 10) = 30, then 30 * 3 = 90. Answer: 90.

-DLIMIT=4 defines LIMIT as 4 before the file's text is seen.

• #ifndef LIMIT is now false → the default #define LIMIT 10 is skipped → LIMIT stays 4.
• SCALE still defined → same branch survives. Substituted: int total = ((2 + 1) * (4)) * 3; → (3 * 4) = 12, then 12 * 3 = 36. Answer: 36. This shows how a single command-line flag rewires the compiled result — the whole point of Build flags -D and the command line.

The preprocessor happily produces: $\text{int main(void) { printf("hi") }}$ No # error occurs — text substitution is legal. The bug is a missing semicolon, which is a syntax rule of C. So it is caught later, at the compiler stage (parsing), not by the preprocessor. Lesson: the preprocessor never validates C grammar; it only pastes and deletes. Fix: #define GREET printf("hi"); or write the ; at the call site.

Cover the solutions and ask yourself three questions per exercise: What text does the preprocessor paste or delete? What does the compiler then evaluate? What number/answer results? If you can narrate those three cleanly, you own this topic.