YOUR C LEARNING COMPANION

Kahan se padhein?

Learning path
Program bananaChapter 40 of 73

Macros: tokens, arguments aur pitfalls

Replacement tokens, grouping, repeated evaluation, stringizing, token pasting aur C23 variadic differences follow karein.

7 min readIntermediateC17 baseline
Offline reading
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

C17 · illustrative fragment
#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.

Complete C17 program
#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

Complete C17 program
#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

Complete C17 program
#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.

C17 · illustrative fragment
#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

Complete C17 program
#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

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.

  1. #define SQUARE(x) ((x) * (x))
  2. int value = SQUARE(2 + 1);
Argument tokensargument2 + 1Preprocessing tokens
Expanded expressionreplacement—Abhi available nahi
intvalue—Abhi available nahi

Replacement 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
  1. Replacement list padhein. x ki dono occurrences ko argument ke tokens milenge. Parameter object nahi banta.
  2. Har x ki jagah 2 + 1 substitute karein. Resulting expression ((2 + 1) * (2 + 1)) hai. Yeh preprocessing hai, multiplication ka execution nahi.
  3. 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.
Apne words mein samjhaayein

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.

Macro parameter ko do baar use karta hai. Side-effecting argument risky kyun ho sakta hai?
Har choice ki explanation padhein
  1. Macro arguments hamesha exactly ek baar evaluate hote hain.

    Token substitution function-call jaisi single-evaluation guarantee nahi deta.

  2. 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.

  3. 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

  1. Missing parentheses. #define SQUARE(x) x * x harmless lagta hai, lekin SQUARE(1 + 2) expand hokar 1 + 2 * 1 + 2 ban 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)).
  2. 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, jisse i ek hi expression mein do baar increment ho jaata hai aur undefined behavior trigger hota hai. Ek real function iske opposite, call se pehle i++ ko exactly ek baar evaluate karta hai.
  3. 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-less if ke body ke roop mein use kiya jaaye, kyunki conditional sirf pehla statement hi capture karta hai. Standard fix body ko do { ... } 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.
  4. Ek preprocessing namespace, C block scope ke bina. Macros, variables ya functions ki tarah scoped nahi hote; ek header mein defined MAX naam 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) #x se STR(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##b se CONCAT(foo, bar), foobar banta 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 calls LOG("ready\n") aur LOG("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.

CHAPTER 40 / 73

Is chapter mein

Macros: tokens, arguments aur pitfalls

Search all 73 chapters in both languages.EN + HG

Try “pointer”, “why int”, or “undefined behavior”.

Concepts connect. Follow your curiosity.↑ ↓ to explore · Enter to open
MAKE YOURSELF COMFORTABLE

Your reading space

Appearance

A clear canvas with balanced contrast.

Text size

100%
AA

Reading tools

Your data stays in this browser

Export a backup before changing browsers or replacing an older version of the reader.

YOUR PERSONAL MARGINS

My notebook

Saved on this device
A LITTLE CLARITY

The glossary

A starting meaning, then a chapter to go deeper.

A QUICK DEFINITION

A little clarity

Read the full explanation →

A thought worth keeping