#define MAX 100
#define MIN 50
#undef MAX
#define MAX 200
int main() {
printf("%d", MAX);
return 0;
}
What will be the output of this program?
The #undef directive undefines the previously defined macro MAX (which was 100). Then MAX is redefined as 200. So printf will output 200. The #undef allows redefining macros without compilation errors.
#define SIZE 10
#define SIZE 20
Redefining a macro with a different value in the same compilation unit causes a compilation error. To redefine, you must #undef first.
#define CONCAT(a,b) a##b
int CONCAT(var,1) = 10;
What is the actual variable name created?
The ## operator (token pasting) concatenates tokens directly. CONCAT(var,1) produces var1 as the variable name, not a##b.
#define STR(x) #x
printf(STR(Hello World));
The # operator (stringification) converts the macro argument into a string literal. STR(Hello World) becomes "Hello World", which printf prints with quotes.
__VA_ARGS__ allows macros to accept a variable number of arguments. Example: #define PRINT(...) printf(__VA_ARGS__) enables flexible argument passing.
#define ADD(x,y) ((x)+(y))
#define MULTIPLY(x,y) ADD(x,y)*ADD(x,y)
What is MULTIPLY(2,3)?
MULTIPLY(2,3) expands to ADD(2,3)*ADD(2,3) = ((2)+(3))*((2)+(3)) = 5*5 = 25. Wait, recalculating: (5)*(5)=25. The answer should be 25, but given options, 36=(2+3)²is if computed as (2+3)*(2+3) with y ignored. Actual answer: ((2)+(3))*((2)+(3))=5*5=25. Correcting: answer is A=25, not B.
#define SQUARE(x) x*x
int result = SQUARE(5+3);
Without parentheses, SQUARE(5+3) expands to 5+3*5+3, which evaluates to 5+15+3=23 due to operator precedence, not (5+3)*(5+3)=64. This demonstrates why macro parameters need parentheses.
#if evaluates constant expressions for conditional compilation. #ifdef checks if a macro is defined, #define creates macros, and #pragma provides compiler-specific directives.
The preprocessor is a text processing tool that processes source code before actual compilation, handling directives like #define, #include, and macros.
int main() { int arr[DOUBLE(5)]; ... }
What is the size of the array?
The macro DOUBLE(5) expands to (2*(5)) = 10 at preprocessing time. Array declarations require compile-time constant expressions, and macro-expanded constants qualify. The array has 10 elements. This works because the macro creates a constant expression that the compiler can evaluate.