Macros: tokens, arguments aur pitfalls
Replacement tokens, grouping, repeated evaluation, stringizing, token pasting aur C23 variadic differences follow karein.
Is chapter mein9 sections
Macro preprocessing tokens replace karta hai. Woh function call jaisa dikh sakta hai, par uske rules alag hain. Grouping, repeated evaluation aur typed function kab clearer interface deta hai, yeh check karenge.
1. Definition replacement tokens deti hai
Object-like macro matching identifier replace karta hai, jaise #define CODEDILE_LIMIT 7. Function-like macro parameters rakhta hai aur naam ke baad next preprocessing token ( ho toh invoke hota hai. Uski definition mein macro name aur opening parenthesis ke beech whitespace nahi honi chahiye. Macros ka C block scope nahi: definition directive se #undef ya preprocessing translation unit ke end tak rehti hai.
Replacement token-based hai. LIMIT macro LIMITED ka part ya "LIMIT" ke characters replace nahi karta. Arguments normally substitution se pehle macro-expand hote hain; # aur ## ke special rules hain. Replacement further macro invocations ke liye rescan hota hai. Apni replacement ke dauran macro khud ko endlessly expand nahi karta. Yeh ordinary text ke har matching piece ko replace karne se zyada precise rules hain.
2. Grouping preserve karke evaluation dekhein
#define CODEDILE_SQUARE(x) ((x) * (x))
int result = CODEDILE_SQUARE(1 + 2);
Har expression parameter aur overall expression ko parenthesize karna precedence surprises se is use ko protect karta hai. In parentheses ke bina 1 + 2 * 1 + 2 five hai. Parentheses repeated evaluation fix nahi karti: CODEDILE_SQUARE(i++) two unsequenced modifications mein expand hoga, jo C17 mein undefined behavior hai. Iska expected output dhoondhne ke liye run na karein.
#include <assert.h>
static inline int square_small(int value)
{
return value * value;
}
int main(void)
{
int next = 3;
int result = square_small(next++);
assert(next == 4);
assert(result == 9);
return 0;
}
Function caller ki single argument expression ek baar evaluate karta hai. Yahan contract deliberately small hai: supplied value ka square int mein representable hona chahiye; function signed overflow safe nahi banata. Different function arguments ka evaluation order C17 mein ab bhi unspecified hai. inline machine-code substitution force nahi karta; static file-scope function ko internal linkage deta hai.
3. Statement macro ek statement jaisa behave kare
#include <assert.h>
#define CODEDILE_SET_ZERO(target) do { (target) = 0; } while (0)
int main(void)
{
int value = 7;
if (value > 0)
CODEDILE_SET_ZERO(value);
else
value = 1;
assert(value == 0);
return 0;
}
do { ... } while (0) wrapper caller ka normal semicolon accept karta hai aur else intended if se attached rakhta hai. Wrapper function-style parameter-type interface add nahi karta; expanded code par ordinary C type checking phir bhi hoti hai. Yeh name collisions remove ya repeated side effects repair bhi nahi karta. Is wrapper ke andar break apne loop se exit karega; automatically outer loop se nahi. Clear translation-time purpose na ho toh function prefer karein.
4. Spellings stringize aur tokens deliberately form karein
#include <assert.h>
#include <string.h>
#define CODEDILE_LIMIT 7
#define CODEDILE_RAW_STRING(x) #x
#define CODEDILE_STRING(x) CODEDILE_RAW_STRING(x)
int main(void)
{
assert(strcmp(CODEDILE_RAW_STRING(CODEDILE_LIMIT), "CODEDILE_LIMIT") == 0);
assert(strcmp(CODEDILE_STRING(CODEDILE_LIMIT), "7") == 0);
return 0;
}
Stringizing operator # unexpanded argument ki spelling use karta hai, specified whitespace aur escaping rules ke saath. Extra wrapper inner macro ke stringize karne se pehle expansion allow karta hai. Example resulting strings compare karta hai; argument ke andar likhi expression evaluate nahi karta.
#define CODEDILE_JOIN_RAW(a, b) a ## b
#define CODEDILE_JOIN(a, b) CODEDILE_JOIN_RAW(a, b)
#define CODEDILE_ID 7
int item7 = 42;
int value = CODEDILE_JOIN(item, CODEDILE_ID);
## ke saath token pasting adjacent pieces se single preprocessing token banata hai. Wrapper yahan bhi pasting se pehle expansion allow karta hai. Result valid preprocessing token hona chahiye; yeh general string concatenation nahi. Macro arguments top-level commas se separate hote hain; nested parentheses commas protect karti hain, sirf braces nahi.
5. Variadic aur version rules clear rakhein
#include <stdio.h>
#define CODEDILE_LOG(...) printf(__VA_ARGS__)
int main(void)
{
CODEDILE_LOG("ready\n");
CODEDILE_LOG("count=%d\n", 2);
return 0;
}
C99 ne variadic macros introduce kiye. Yeh C17 form poori nonempty argument list __VA_ARGS__ mein rakhta hai, isliye dono shown calls work karti hain. Named fmt parameter aur printf(fmt, __VA_ARGS__) wale different form ko C17 mein suitable additional arguments chahiye; omitted tail portable comma-removal trick nahi. Logging macro par printf ke format aur argument contracts apply rehte hain.
Primary references aur aage ki reading
- WG14 N1570 — public C11 committee draft: 6.10.3, 6.5p2, 6.7.4. C17 baseline ke stable core rules ke liye; final ISO publication nahi.
- WG14 N3096 — public C23 working draft: 6.10.4. C23 notes C17 example checks se separate hain.
- GCC CPP: macro pitfalls
Expression evaluation se pehle macro expansion hota hai
Visual model explore karein
VISUAL MODEL
Argument tokens ko do replacement lists mein follow karein. Phir resulting C expression ko uski grouping se evaluate karein.
Examples sirf side-effect-free int expressions 3 aur 2 + 1 use karte hain. Function ke fragment se pehle macro definition hai.
#define SQUARE(x) ((x) * (x))int value = SQUARE(2 + 1);
argument2 + 1Preprocessing tokensreplacement—Abhi available nahivalue—Abhi available nahiReplacement list padhein. x ki dono occurrences ko argument ke tokens milenge. Parameter object nahi banta.
Parentheses is grouping problem ko fix karte hain; repeated argument ko sirf ek baar evaluate nahi karwate. Macro function call nahi hai. Model kabhi SQUARE(i++) ya doosri unsequenced modifications run nahi karta.
Poora trace padhein
- Replacement list padhein. x ki dono occurrences ko argument ke tokens milenge. Parameter object nahi banta.
- Har x ki jagah 2 + 1 substitute karein. Resulting expression ((2 + 1) * (2 + 1)) hai. Yeh preprocessing hai, multiplication ka execution nahi.
- Execution mein resulting expression se 9 milta hai. Parentheses grouping decide karte hain; function-call boundary add nahi karte.
Aage badhne se pehle
- Macros preprocessing tokens replace karte hain; functions jaise typed argument values nahi lete.
- Parentheses grouping repair kar sakti hain; repeated evaluation nahi rok sakti.
- Stringizing, token pasting aur conditional forms ke specific rules hain.
In ideas ko alag rakhein
- Grouped argument / Single evaluation
- Parentheses mein argument bhi macro replacement mein kai baar expand ho sakta hai.
Side-effecting argument wale function-like macro ke bajaye small typed function clearer kyun ho sakta hai?
Optional: bolkar samjhein ya note rakhein. Tayyar hon toh aage badh sakte hain.Apni understanding check karein
Optional hai. Answers save ya send nahi hote; chapter kabhi lock nahi hota.
Har choice ki explanation padhein
- Macro arguments hamesha exactly ek baar evaluate hote hain.
Token substitution function-call jaisi single-evaluation guarantee nahi deta.
- Expansion expression ko ek se zyada baar evaluate kar sakti hai; sequencing bhi matter karti hai.
✓ Sahi reasoning. Replacement tokens aur sequencing inspect karein; invalid expansion ka output assume na karein.
- Parentheses har repeated side effect automatically hata deti hain.
Parentheses grouping improve kar sakti hain, duplicated evaluations nahi hataati.
C17
Earlier edition ka quick reference
Existing section links aur saved passages ke liye retained. Expanded explanation upar hai; documented corrections source review mein recorded hain.
Macro replacement ordinary C semantic analysis se pehle preprocessing tokens par hota hai. Yeh function-style type checking ya C block scope follow nahi karta. Macro definition apne #define se corresponding #undef ya us preprocessing translation unit ke end tak apply hoti hai; doosri separately compiled files mein automatically active nahi hoti.
Object-like vs. Function-like Macros
- Object-like macros naam ko preprocessing tokens ki replacement list se associate karte hain; list empty bhi ho sakti hai:
#define PI 3.14159. - Function-like macros preprocessing-token arguments lete hain aur replacement list substitute karte hain; result ka expression hona zaroori nahi:
#define SQUARE(x) ((x) * (x)).
Common Pitfalls
- Missing parentheses.
#define SQUARE(x) x * xharmless lagta hai, lekinSQUARE(1 + 2)expand hokar1 + 2 * 1 + 2ban jaata hai, jiski value 9 nahi balki 5 aati hai. Is expression macro mein har substituted operand aur complete expression ko parentheses dein:#define SQUARE(x) ((x) * (x)). - Side effects ka multiple evaluation. Kyunki macro parameter body mein jahan bhi appear hota hai wahan substitute ho jaata hai,
SQUARE(i++)expand hokar((i++) * (i++))ban jaata hai, jisseiek hi expression mein do baar increment ho jaata hai aur undefined behavior trigger hota hai. Ek real function iske opposite, call se pehlei++ko exactly ek baar evaluate karta hai. - Single-line contexts mein multi-statement macros.
#define SWAP(a,b) t=a; a=b; b=t;jaisa macro tab break ho jaata hai jab isse brace-lessifke body ke roop mein use kiya jaaye, kyunki conditional sirf pehla statement hi capture karta hai. Standard fix body kodo { ... } while (0)mein wrap karna hai, jo ek single statement ki tarah behave karta hai lekin call site par normal trailing semicolon bhi allow karta hai. - Ek preprocessing namespace, C block scope ke bina. Macros, variables ya functions ki tarah scoped nahi hote; ek header mein defined
MAXnaam ka macro kahin aur defined identically-named variable, function, ya macro ke saath silently collide kar sakta hai, kyunki replacement identifier preprocessing tokens ko match karta hai; function-like macro tab expand hota hai jab next preprocessing token(ho. String ya character literals ke andar names replace nahi hote.
Special Preprocessor Operators
- Stringizing operator
#argument ke token spelling ko string literal banata hai:#define STR(x) #xseSTR(hello),"hello"banta hai.#wale arguments pehle macro-expand nahi hote; stringizing se pehle expansion chahiye toh doosra wrapper macro use karein. - Token-pasting operator
##adjacent preprocessing tokens jodta hai:#define CONCAT(a,b) a##bseCONCAT(foo, bar),foobarbanta hai. Result valid preprocessing token hona chahiye; pasting se pehle adjacent arguments expand karne ke liye additional macro layer chahiye. - Variadic macros (C99)
...aur__VA_ARGS__use karte hain.#define LOG(...) printf(__VA_ARGS__)dono callsLOG("ready\n")aurLOG("x=%d\n", x)accept karta hai.#define LOG(fmt, ...) printf(fmt, __VA_ARGS__)wali form ko C17 mein suitable nonempty variadic argument chahiye, warna invalid trailing comma aayega. C23 conditional token insertion ke liye__VA_OPT__add karta hai.__VA_ARGS__aur__VA_OPT__preprocessing facilities hain, additional language keywords nahi.
Macros vs. Inline Functions
Jab normal typed function operation express kar sakta ho, static inline prefer karein. Har supplied argument expression ek baar evaluate hota hai, lekin different arguments ke evaluation ka order C17 mein phir bhi unspecified hai. Function ke andar parameter baar-baar use karne se caller expression dobara evaluate nahi hota. Inlining guaranteed nahi hai aur optimization debugger visibility affect kar sakti hai. Token manipulation aur kuch generic interfaces mein macros useful rehte hain.
Agla idea padhne ke liye tayyar?
Mark this chapter as read whenever you feel ready.