C ko step by step dekhein.
11 models mein C ke ideas step by step dekhein. Model kholein, case choose karein aur apni pace par trace follow karein. Poora text trace bhi available hai.
Value copy hote hue dekheinC17
Value copy hote hue dekhein
VISUAL MODEL
Starting value badlein aur teen lines follow karein. Dono objects ko alag dekhein.
Maan lijiye declarations function ke andar hain.
int apples = 4;int saved = apples;apples = 6;
applesInitializer tak nahi pahunchesavedInitializer tak nahi pahuncheAbhi dono initializers tak nahi pahunche. Trace mein apples ya saved ki starting value abhi nahi dikhayi gayi.
Diagram logical objects aur values dikhata hai. Physical storage aur optimisation implementation par depend karte hain.
Poora trace padhein
- Abhi dono initializers tak nahi pahunche. Trace mein apples ya saved ki starting value abhi nahi dikhayi gayi.
- Initializer apples ko value 4 deta hai. Later assignment se value badalne par bhi naam aur type same rehte hain.
- Initializer saved ko 4 ki copy deta hai. Dono integer objects ki values separate hain.
- apples mein ab 6 hai. saved mein pehle copy hui value 4 ab bhi hai.
Do pointers aur unke targets follow kareinC17
Do pointers aur unke targets follow karein
VISUAL MODEL
Pointer copy karein, ek copy redirect karein aur dono ke through write karein. Arrows batate hain ki har pointer value kis object ko refer karti hai.
Function ke andar int left = 4; aur int right = 8; se shuru karein.
int *p = &left;int *q = p;p = &right;*q = 6;*p = 9;
pPoint karta haiInitializer tak nahi pahuncheqPoint karta haiInitializer tak nahi pahuncheleft4right8left aur right initialise hain. Pointer objects p aur q ke initializers tak abhi nahi pahunche.
Poore trace mein left aur right live aur writable hain. Arrows relationships dikhate hain; actual pointer representation implementation par depend karti hai.
Poora trace padhein
- left aur right initialise hain. Pointer objects p aur q ke initializers tak abhi nahi pahunche.
- p ko left ka pointer mila. left ki value p mein copy nahi hui; p pointer value hold karta hai.
- q ko p ki pointer value ki copy mili. Ab dono left ko refer karte hain.
- p ab right ko refer karta hai. q apni copied pointer value ki wajah se ab bhi left ko refer karta hai.
- q ke through 6 write karne se left badla. q khud ab bhi left ko refer karta hai.
- p ke through 9 write karne se right badla. Kaunsa integer badlega, yeh decide karne se pehle pointer ka current target dekhein.
Recursive calls aur returns follow kareinC17
Recursive calls aur returns follow karein
VISUAL MODEL
Small input choose karke triangle(n) follow karein. Dekhein kaunsi call wait karti hai aur kis result se caller aage badhta hai.
triangle 1 se n tak unsigned integers add karta hai. Har invocation ka apna n parameter hai.
if (n == 0U) return 0U;return n + triangle(n - 1U);
Abhi koi call in progress nahi hai.
triangle(3) call karne ke liye tayyar hain. Abhi koi call shuru nahi hui.
Input 0–5 tak hai aur har sum unsigned int mein fit hai. Yeh source-level calls ka model hai; storage layout aur call optimisation implementation details hain.
Poora trace padhein
- triangle(3) call karne ke liye tayyar hain. Abhi koi call shuru nahi hui.
- triangle(3) mein enter karein. Is call ki apni parameter value 3 hai.
- triangle(2) mein enter karein. Is call ki apni parameter value 2 hai.
- triangle(1) mein enter karein. Is call ki apni parameter value 1 hai.
- triangle(0) mein enter karein. Is call ki apni parameter value 0 hai.
- triangle(0) stopping case par 0 return karta hai. Chhoti call ki need nahi.
- triangle(0) ne 0 return kiya. Caller triangle(1) ab 1 + 0 calculate karke 1 return kar sakta hai.
- triangle(1) ne 1 return kiya. Caller triangle(2) ab 2 + 1 calculate karke 3 return kar sakta hai.
- triangle(2) ne 3 return kiya. Caller triangle(3) ab 3 + 3 calculate karke 6 return kar sakta hai.
- Saari calls finish hain. triangle(3) ne original caller ko 6 return kiya.
Array mein pointer move kareinC17
Array mein pointer move karein
VISUAL MODEL
Index choose karein. Pointer ka target aur one-past boundary dekhein.
Function ke andar a mein teen initialized int elements hain. Index 3 boundary hai, chautha element nahi.
int a[3] = {3, 6, 9};int *p = a;p = a + 1;if (p != a + 3) { int value = *p; (void)value; }
a[0]3Array elementa[1]6Array elementa[2]9Array elementa + 3—One-past; read na karein- p ka target
- —
- Read ki value
- —
a ke teen elements 3, 6 aur 9 hain. Pointer initializer tak abhi nahi pahunche.
Pointer steps elements count karte hain, fixed bytes nahi. One-past pointer yahan ban aur compare ho sakta hai, dereference nahi. Bounds ke bahar koi read execute nahi hoti.
Poora trace padhein
- a ke teen elements 3, 6 aur 9 hain. Pointer initializer tak abhi nahi pahunche.
- Is initializer mein a first element ke pointer mein convert hota hai. p, a[0] ko point karta hai.
- p ko a + 1 milta hai. Index jodne par utne int elements aage jaate hain.
- Yeh pointer ek element ko refer karta hai. *p read karne par 6 milta hai. a[1] bhi wahi element hai.
String kahan end hoti hai?C17
String kahan end hoti hai?
VISUAL MODEL
Array size fixed rakhein aur pehla null character badlein. String length ka change dekhein.
Yeh fragments function ke andar hain aur <string.h> included hai. Dono choices teen basic execution characters use karti hain.
char text[6] = "cat";size_t before = strlen(text);text[1] = '\0';size_t after = strlen(text);
text[0]—Initializer tak nahi pahunchetext[1]—Initializer tak nahi pahunchetext[2]—Initializer tak nahi pahunchetext[3]—Initializer tak nahi pahunchetext[4]—Initializer tak nahi pahunchetext[5]—Initializer tak nahi pahunche- Array capacity
- 6
- Is step ka strlen result
- —
Initializer tak abhi nahi pahunche. Declared capacity chhe char elements hai.
Capacity saare array elements count karti hai. strlen pehle null se pehle ke characters count karta hai; terminator count nahi hota. Pehle null likhne se baad ke bytes erase nahi hote.
Poora trace padhein
- Initializer tak abhi nahi pahunche. Declared capacity chhe char elements hai.
- Literal teen letters aur ek null initialize karta hai. Baaki do elements bhi zero-initialized hote hain.
- strlen(text), 3 hai. Capacity 6 hai. Pehla null index 3 par hai.
- Index 1 par null likhne se pehle terminator ban jaata hai. Baad ke elements ke stored characters wahi rehte hain.
- Ab strlen(text), 1 hai. Array mein ab bhi chhe elements hain; length aur capacity alag facts hain.
Function argument ki copy dekheinC17
Function argument ki copy dekhein
VISUAL MODEL
Parameter ko value milte aur badalte dekhein. Caller ka object alag rehta hai.
replace alag function hai. Aakhri do lines us doosre function ke andar hain jo ise call karta hai.
void replace(int x) {x = 9;}/* inside a different function: */int caller = 4;replace(caller);
caller4Caller ka objectx—Abhi active parameter nahiCalling function mein caller, 4 se initialized hai. Abhi replace call active nahi hai.
C argument ki value pass karta hai. Pointer argument bhi copy hota hai; copied pointer phir bhi caller ke saath shared object ko refer kar sakta hai. Is model mein int pass hota hai.
Poora trace padhein
- Calling function mein caller, 4 se initialized hai. Abhi replace call active nahi hai.
- Argument expression caller apni current value, 4 deta hai.
- Parameter x alag int object hai, jo argument value 4 se initialize hota hai.
- x ko 9 milta hai. caller mein 4 hi hai kyunki woh alag object hai.
- replace return karta hai. Parameter ki lifetime end hoti hai; caller mein 4 hi rehta hai.
Visibility aur lifetime alag samjheinC17
Visibility aur lifetime alag samjhein
VISUAL MODEL
Inner block ke ordinary local aur static local ko follow karein. Names aur objects alag track karein.
Inner block ek chal rahe function ke andar hai. local non-VLA automatic int hai. kept ki static storage duration hai aur initialization program startup se pehle hoti hai.
/* inside a function, before the inner block */{static int kept = 2;int local = 3;/* both names are visible here */}/* outside the inner block */
kept2Alive; naam scope se baharlocal—Lifetime shuru nahi; naam hiddenInner block se pehle kept alive hai, par uska naam yahan scope mein nahi. local ki lifetime shuru nahi hui.
Scope batata hai naam kahan visible hai. Lifetime batati hai object kab exist karta hai. Ordinary non-VLA automatic object ki lifetime block entry par shuru hoti hai, initializer tak pahunchne se pehle.
Poora trace padhein
- Inner block se pehle kept alive hai, par uska naam yahan scope mein nahi. local ki lifetime shuru nahi hui.
- Block mein enter karne se local ki lifetime shuru hoti hai. Yahan uska naam abhi declare nahi hua aur initializer nahi chala.
- kept ki declaration uska naam scope mein laati hai. Usmein pehle se 2 hai; block entry use dobara initialize nahi karti.
- local ki declaration naam visible karti hai aur initializer 3 store karta hai. Dono objects alive hain.
- Yahan dono names visible aur dono objects alive hain. Yeh alag properties hain.
- Block chhodne par local ki lifetime end hoti hai. kept alive rehta hai, par yahan dono names apne scope se bahar hain.
- kept ab bhi value 2 ke saath exist karta hai. Model uska state batata hai; yahan code out-of-scope naam directly use nahi kar sakta.
Allocation resize aur release kareinC17
Allocation resize aur release karein
VISUAL MODEL
Positive-size realloc ki dono outcomes dekhein. Owning pointer aur temporary result ko follow karein.
Function definition se pehle <stdlib.h> include karein. Fragment void function ke andar chalega. Pehla malloc successful maana hai. realloc outcome teaching scenario hai, real allocator control nahi.
int *p = malloc(2 * sizeof *p);if (p == NULL) return;p[0] = 4; p[1] = 8;int *tmp = realloc(p, 3 * sizeof *p);if (tmp != NULL) {p = tmp;p[2] = 12;}free(p);p = NULL; tmp = NULL;
p—Initializer tak nahi pahunchetmp—Initializer tak nahi pahuncheB (allocation)—Abhi allocation nahiAbhi allocation request nahi hui. Dono pointer initializers tak nahi pahunche.
A aur B logical allocation labels hain, addresses nahi. ? ka matlab value read nahi karni. Successful realloc purani allocation ki lifetime end karta hai, chahe implementation address reuse kare. Sirf positive sizes use hoti hain.
Poora trace padhein
- Abhi allocation request nahi hui. Dono pointer initializers tak nahi pahunche.
- malloc successful hai aur p allocation A own karta hai, jismein do int objects ki jagah hai. Unki values initialized nahi hain.
- Dono int values 4 aur 8 ho jaati hain. Requested allocation size, sizeof *p se express ki gayi thi.
- realloc successful hai. tmp allocation B ko refer karta hai; pehli do values preserved hain. Purani allocation end ho chuki, isliye p ki purani value read nahi karni.
- p ko tmp milta hai: unusable purani value ko read kiye bina replace kiya jaata hai. Ab p, B own karta hai; tmp alias hai.
- p[2] ko 12 milta hai. Ab B ki teeno int values initialized hain.
- free live allocation ko ek baar release karta hai. Use refer karne wali pointer values baad mein read nahi karni. Released storage se koi value read nahi hoti.
- Dono pointer objects ko NULL assign hota hai. Yeh purani values replace karta hai; koi extra allocation release nahi hoti.
Source se program tak follow kareinC17
Source se program tak follow karein
VISUAL MODEL
Headers, macro replacement, translation units aur external definitions ko jodein. Ek definition chhodkar bhi dekhein.
Labelled excerpts config.h, main.c aur scale.c ke hain. Definition choice batati hai build mein scale.c diya gaya ya nahi.
/* config.h */ #define FACTOR 2int scale(int);/* main.c */ #include "config.h"int main(void) { return scale(3); }/* scale.c */ #include "config.h"int scale(int n) { return n * FACTOR; }
source—Current stagepreprocess—Baad ka stagecompile—Baad ka stagelink—Baad ka stageprogram—Baad ka stageconfig.h, scale declare aur FACTOR ko 2 define karta hai. main.c, scale call karta hai; build mein diya ho to scale.c definition deta hai.
Yeh translation phases ki conceptual grouping hai. Alag .o files aur compiler/linker executables common toolchain choices hain; C in artifacts ko require nahi karta. In chhoti files ko standard library function nahi chahiye.
Poora trace padhein
- config.h, scale declare aur FACTOR ko 2 define karta hai. main.c, scale call karta hai; build mein diya ho to scale.c definition deta hai.
- Har source file separately preprocess hoti hai. Header declarations deta hai aur scale.c ke FACTOR tokens, 2 ban jaate hain.
- Resulting translation units analyze aur translate hoti hain. Declaration ke saath main.c translate ho sakta hai; scale ki body main.c mein rakhna zaroori nahi.
- External call doosri translation unit ki scale definition se connect hoti hai.
- Linked program run ho sakta hai. scale(3), 6 compute karta hai aur main wahi value return karta hai.
Result se pehle type ko follow kareinC17
Result se pehle type ko follow karein
VISUAL MODEL
Operands, operation aur destination ki conversion ko alag dekhein. Yeh reasoning stages hain, alag machine instructions nahi.
Har case function ke andar ka fragment hai. Unsigned-char case specifically CHAR_BIT == 8 assume karta hai; yeh macro <limits.h> se milta hai.
int numerator = 5, denominator = 2;double ratio = numerator / denominator;
numerator5Operand ki valuedenominator2Operand ki valuenumerator / denominator—Abhi value available nahiratio—Abhi value available nahiDono operands int hain. ratio ka type double hoga, par isse division ke operand types nahi badalte.
Cast range check nahi karta. Operand conversion se original objects nahi badalte. C 8-bit bytes require nahi karta; sirf labeled unsigned-char case yeh assume karta hai. C23 mein bhi signed overflow undefined hai.
Poora trace padhein
- Dono operands int hain. ratio ka type double hoga, par isse division ke operand types nahi badalte.
- 5 / 2 integer division hai, isliye quotient int value 2 hai. Yeh card expression result dikhata hai, ratio ki declaration mein change nahi.
- int quotient 2, double mein convert hokar ratio ko 2.0 se initialize karta hai. Fraction pehle hi discard ho chuka hai.
Expression evaluation se pehle macro expansion hota haiC17
Expression evaluation se pehle macro expansion hota hai
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.