Question bank — Preprocessor directives — #define, #ifdef, #ifndef, #include guards

False — a macro is pure text substitution; it has no memory address, no type, and vanishes before the compiler runs. Only real objects like const int reserve memory.

False — the macro is untyped text with no scope and is invisible to the debugger; the const is a typed object with an address and normal scoping. They only look alike.

False — the preprocessor ignores {} and functions entirely; a macro is live from its #define line to the end of the file (or until #undef), regardless of braces.

False — #ifdef only asks "does this name exist as a macro?" Even #define DEBUG 0 still makes #ifdef DEBUG true, because the name is defined.

False — it changes results. Without them, blind pasting lets surrounding operators mis-group the text, so SQUARE(a+b) becomes a+b*a+b instead of the intended product.

True — both ensure a header's body is included at most once per translation unit; #ifndef is standard and portable, #pragma once is a widely-supported compiler extension.

False — whichever header is included first defines HEADER_H, so the second header sees its guard as already-defined and gets entirely deleted. Tags must be unique.

False — there is no runtime cost at all; the preprocessor deletes the text before compilation, so the disabled lines never become code in the first place.

False — it copies the header's entire text in place, as if you had pasted it by hand. That literal duplication is exactly why include guards are needed.

The trailing ; is part of the substituted text, so it expands to int arr[100;];, a syntax error. Directives are not C statements — never end them with a semicolon.

It expands to 3 + 1 * 3 + 1 = 7 because * binds tighter than +. Fix: #define SQUARE(x) ((x) * (x)).

It expands to 1 / (4) / 2 = (1/4)/2, not 1 / 2. The body needs outer parentheses too: #define HALF(x) ((x) / 2).

The #endif. Every #ifdef/#ifndef/#if block must be closed, or the preprocessor keeps swallowing lines to the end of the file and errors out.

It never #defines CONFIG_H, so #ifndef is true on every inclusion and the struct still gets pasted twice. The middle #define CONFIG_H line is mandatory.

The = is substituted as text, so int x = NAME; becomes int x = = value;. #define uses a space, not an equals sign: #define NAME value.

It expands to 1+2 * 3 = 1 + 6 = 7. Wrap the whole body: #define ADD(a,b) ((a)+(b)) so it becomes ((1)+(2)) * 3 = 9.

A function evaluates its arguments to values first, so precedence is already settled. A macro pastes raw text, so surrounding operators can reach inside and regroup it — parentheses fence off that text.

You want to act only when something is absent — define the header body the first time (before its tag exists), or supply a default only when no external value was given. That "if not already there" logic is exactly #ifndef.

All the debug code sits inside #ifdef DEBUG; without the define, the preprocessor deletes that text, so those printfs never reach the compiler and never appear in the executable.

The -D flag defines the macro before your file is processed, so by the time the file's #ifndef BUFFER_SIZE runs, the name already exists and the default block is skipped. See Build flags -D and the command line.

Redefining a struct gives the compiler two conflicting descriptions of the same type; redeclaring a function just repeats the same signature harmlessly. Headers full of struct definitions are the reason guards exist — see Header files and translation units.

The preprocessor runs first and replaces every PI token with 3.14159; the translation unit handed to the compiler has no # lines and no macro names left. This ordering is the whole pipeline.

Typed constants give you type-checking, scope, and debugger visibility that text macros lack; but guards and configuration toggles are about controlling text inclusion, which only the preprocessor can do.

Not for that build — one inclusion pastes the body once with no conflict. But the moment another file includes it transitively, you get double-pasting; guards are cheap insurance you add regardless.

Legal — the name is defined to empty text. #ifdef EMPTY is true (it exists), and using EMPTY in code substitutes nothing, effectively deleting the token.

The compiler warns/errors about redefinition (unless the bodies are identical). To reassign intentionally you must #undef it first, then #define again.

No — it only prevents defining MAX if it's unset at that point. Anything after the #endif is free to #undef and redefine it; the guard is a one-time gate, not a lock.

It expands only once — the preprocessor blocks a macro from recursively expanding its own name, so N becomes N + 1 and the inner N is left as-is (a real symbol or an error), preventing infinite substitution.

No — the block's text is deleted before the compiler sees it, so a syntax error hidden in dead conditional code goes unnoticed until someone actually defines DEBUG.

Yes — spaces and tabs between # and the keyword are legal and ignored. The # just has to be the first non-blank token on the line.