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

5.1.27 · D5 · Coding › C Programming › Preprocessor directives — #define, #ifdef, #ifndef, #include

True or false — justify karo

Har #define ek value ke liye memory reserve karta hai, jaise ek variable karta hai.

False — macro pure text substitution hai; iski koi memory address nahi, koi type nahi, aur compiler run hone se pehle hi ye gayab ho jaata hai. Sirf real objects jaise const int memory reserve karte hain.

#define PI 3.14159 aur const double PI = 3.14159; har tarah se interchangeable hain.

False — macro untyped text hai jiska koi scope nahi aur debugger ko dikhta bhi nahi; const ek typed object hai jiska address hai aur normal scoping hai. Ye sirf dikhne mein alike lagte hain.

Ek macro C ka block scope respect karta hai, isliye kisi function ke andar #define karna use us function tak limit kar deta hai.

False — preprocessor {} aur functions ko bilkul ignore karta hai; ek macro apni #define line se lekar file ke end tak (ya #undef tak) live rehta hai, braces se koi fark nahi padta.

#ifdef DEBUG check karta hai ki DEBUG ki non-zero value hai ya nahi.

False — #ifdef sirf yeh poochta hai "kya yeh naam ek macro ke roop mein exist karta hai?" Yahan tak ki #define DEBUG 0 bhi #ifdef DEBUG ko true bana deta hai, kyunki naam defined toh hai.

Macro body ko parentheses mein wrap karna sirf ek style preference hai.

False — isse results change hote hain. Unke bina, blind pasting se surrounding operators text ko galat tarike se group kar lete hain, toh SQUARE(a+b) intended product ki jagah a+b*a+b ban jaata hai.

#pragma once aur classic #ifndef guard ek hi goal achieve karte hain.

True — dono ensure karte hain ki ek header ki body ek translation unit mein zyada se zyada ek baar include ho; #ifndef standard aur portable hai, #pragma once ek widely-supported compiler extension hai.

Do alag-alag headers safely guard tag HEADER_H reuse kar sakte hain.

False — jo bhi header pehle include hoti hai woh HEADER_H define kar deti hai, isliye doosri header apna guard already-defined dekh ke poori tarah delete ho jaati hai. Tags unique hone chahiye.

Preprocessor ek #ifdef block ko runtime par skip karne ke liye machine code generate karke remove karta hai.

False — runtime cost bilkul bhi nahi hoti; preprocessor compilation se pehle text delete kar deta hai, isliye disabled lines pehle-kabhi code nahi banti.

#include "file.h" tumhare file mein header ka ek reference copy karta hai.

False — yeh header ka poora text wahan paste kar deta hai, jaise tumne khud haath se paste kiya ho. Yahi literal duplication ki wajah se include guards ki zaroorat padti hai.

Error dhundho

#define MAX 100; ko int arr[MAX]; ke roop mein use karna — kya tootta hai?

Trailing ; substituted text ka hissa ban jaata hai, isliye yeh int arr[100;]; expand hota hai, jo ek syntax error hai. Directives C statements nahi hain — unhe kabhi semicolon se end mat karo.

#define SQUARE(x) x * x ko SQUARE(3 + 1) ke roop mein use karna — 16 kyun nahi?

Yeh 3 + 1 * 3 + 1 = 7 expand hota hai kyunki *, + se zyada tightly bind karta hai. Fix: #define SQUARE(x) ((x) * (x)).

#define HALF(x) (x) / 2 ko 1 / HALF(4) ke roop mein use karna — 1/2 kyun nahi?

Yeh 1 / (4) / 2 = (1/4)/2 expand hota hai, 1 / 2 nahi. Body ko outer parentheses bhi chahiye: #define HALF(x) ((x) / 2).

#ifdef WINDOWS
  use_win();
#else
  use_posix();

Kya missing hai?

#endif. Har #ifdef/#ifndef/#if block ko close karna zaroori hai, warna preprocessor file ke end tak lines ko consume karta rehta hai aur error deta hai.

#ifndef CONFIG_H
struct Cfg { int n; };
#endif

Yeh properly guard kyun nahi karta?

Yeh kabhi CONFIG_H #define nahi karta, isliye #ifndef har inclusion par true hota hai aur struct fir bhi do baar paste hoti hai. Beech wali #define CONFIG_H line mandatory hai.

#define NAME = value (= ke saath) — kya galat hoga?

= text ke roop mein substitute hota hai, isliye int x = NAME; ban jaata hai int x = = value;. #define mein equals sign nahi, space use hota hai: #define NAME value.

Ek macro #define ADD(a,b) a+b ko ADD(1,2) * 3 ke roop mein use karne par 9 ki jagah 7 milta hai — kyun?

Yeh 1+2 * 3 = 1 + 6 = 7 expand hota hai. Puri body wrap karo: #define ADD(a,b) ((a)+(b)) taaki yeh ((1)+(2)) * 3 = 9 ban jaaye.

Why questions

Preprocessor ko parentheses ki zaroorat kyun padti hai jab ek real function ko kabhi nahi padti?

Ek function apne arguments ko pehle values mein evaluate karta hai, isliye precedence pehle se settle ho jaati hai. Ek macro raw text paste karta hai, isliye surrounding operators andar ghus ke use regroup kar sakte hain — parentheses us text ko fence kar dete hain.

Headers aur default values ke liye guard #ifdef nahi, #ifndef (not) kyun hai?

Tum tab act karna chahte ho jab kuch absent ho — header body pehli baar define karo (jab uska tag exist nahi karta), ya default sirf tab provide karo jab koi external value na di gayi ho. "Agar abhi tak wahan hai nahi" wala logic exactly #ifndef hai.

Ek #define DEBUG line ko comment out karna tumhara binary kyun chhota kar sakta hai?

Saara debug code #ifdef DEBUG ke andar hota hai; define ke bina, preprocessor us text ko delete kar deta hai, isliye woh printfs kabhi compiler tak nahi pahunchte aur executable mein appear nahi hote.

Build flag jaise -DBUFFER_SIZE=1024 in-file default se kyun jeet jaata hai?

-D flag macro ko tumhari file process hone se pehle define karta hai, isliye jab file ka #ifndef BUFFER_SIZE run hota hai, naam pehle se exist karta hai aur default block skip ho jaata hai. Dekho Build flags -D and the command line.

Duplicated struct definition ek error kyun hai lekin duplicated function declaration aksar nahi?

Ek struct redefine karne se compiler ko same type ke do conflicting descriptions milte hain; ek function redeclare karna sirf same signature ko harmlessly repeat karta hai. Struct definitions se bhari headers ki wajah se guards exist karte hain — dekho Header files and translation units.

Compiler kabhi PI shabd nahi dekhta #define PI 3.14159 se — kyun?

Preprocessor pehle run karta hai aur har PI token ko 3.14159 se replace kar deta hai; compiler ko jo translation unit milta hai usme koi # lines nahi hote aur koi macro names nahi bacha hota. Yahi ordering poori pipeline hai.

Typed constants ke liye #define ki jagah const/enum prefer kyun karte hain, lekin guards ke liye #define kyun rakhte hain?

Typed constants type-checking, scope, aur debugger visibility dete hain jo text macros mein nahi hoti; lekin guards aur configuration toggles text inclusion control karne ke baare mein hain, jo sirf preprocessor kar sakta hai.

Edge cases

Agar kisi header mein koi include guard nahi hai lekin use sirf ek baar include kiya gaya hai, toh kya fark padta hai?

Us build ke liye nahi — ek inclusion body ko ek baar bina kisi conflict ke paste karta hai. Lekin jab bhi koi doosri file isse transitively include karti hai, double-pasting hoti hai; guards sasti insurance hai jo tum regardless add karte ho.

#define EMPTY (koi replacement text nahi) — kya yeh legal hai, aur #ifdef EMPTY kya karta hai?

Legal — naam empty text mein defined hai. #ifdef EMPTY true hai (woh exist karta hai), aur code mein EMPTY use karne par kuch bhi substitute nahi hota, effectively token delete ho jaata hai.

Kya hoga agar tum ek macro #define karo jo pehle se alag body ke saath defined hai?

Compiler redefinition ke baare mein warn/error karta hai (jab tak bodies identical na hon). Intentionally reassign karne ke liye pehle #undef karna hoga, phir dobara #define karna hoga.

Kya #ifndef MAX / #define MAX 100 / #endif same file mein baad mein MAX redefine hone se protect karta hai?

Nahi — yeh sirf us point par MAX define hone se rokta hai agar woh unset ho. #endif ke baad kuch bhi #undef aur redefine karne ke liye free hai; guard ek one-time gate hai, lock nahi.

Kya ek macro khud ko reference karke expand ho sakta hai, jaise #define N N + 1?

Yeh sirf ek baar expand hota hai — preprocessor ek macro ko uske apne naam ko recursively expand karne se rokta hai, isliye N ban jaata hai N + 1 aur andar wala N as-is reh jaata hai (ek real symbol ya error), infinite substitution rokne ke liye.

Agar #ifdef DEBUG ek syntax error wale code ko wrap karta hai, lekin DEBUG undefined hai, toh kya build fail hogi?

Nahi — block ka text compiler ke dekhne se pehle delete ho jaata hai, isliye dead conditional code mein chupi syntax error tab tak unnoticed rehti hai jab tak koi actually DEBUG define na kare.

Kya # aur directive name ke beech whitespace allowed hai, jaise # define X 1?

Haan — # aur keyword ke beech spaces aur tabs legal hain aur ignore hote hain. # bas line par pehla non-blank token hona chahiye.

Recall Ise lock karne ke liye ek-line summary

Is page par har trap same trap hai alag costume mein: preprocessor text edit karta hai aur kuch nahi samajhta — na types, na values, na scope, na runtime. Isi se reason karo aur tum har answer khud derive kar sakte ho.

Related deep dives jinhe revisit karna worth hai: Macros vs inline functions aur Conditional compilation for cross-platform code.