Code10x

Compiled language mein, source code (.c file) ko compiler pehle poori tarah machine code mein convert karta hai (.exe/binary), phir wo binary run hoti hai. Interpreted languages (jaise Python) line-by-line, run-time par translate hoti hain — isliye C generally FASTER hoti hai.

main() program ka ENTRY POINT hai — jab bhi ek C program run hota hai, execution HAMESHA main() function se SHURU hota hai, chahe program mein aur bhi functions kahin bhi defined hon.

printf() output CONSOLE par PRINT karta hai (format specifiers %d, %s, %f use karke). scanf() user se INPUT LETA hai, aur usse variables mein STORE karta hai.

C ek STATICALLY TYPED language hai — compiler ko PEHLE SE pata hona chahiye variable KITNI memory LEGA, aur USME KAUN SI OPERATIONS VALID hain. Isse COMPILE-TIME PAR hi type errors pakde jaate hain.

int WHOLE numbers store karta hai. float aur double DECIMAL numbers store karte hain (double zyada PRECISION deta hai). char EK SINGLE character store karta hai (ASCII value ke roop mein).

Ek expression mein, agar MULTIPLE operators hon (jaise 2 + 3 * 4), precedence DECIDE karti hai KAUN SA operator PEHLE evaluate hoga — multiplication (*) HAMESHA addition (+) se PEHLE evaluate hota hai.

if-else COMPLEX CONDITIONS (ranges, multiple variables) ke liye BEHTAR hai. switch EK SINGLE variable ki MULTIPLE, SPECIFIC values check karne ke liye zyada CLEAN aur READABLE hai.

for loop tab use hota hai jab ITERATIONS ki COUNT PEHLE SE pata ho. while loop CONDITION check karke loop SHURU karta hai (0 baar bhi chal sakta hai). do-while HAMESHA KAM SE KAM EK BAAR chalta hai, phir condition check karta hai.

break loop ko COMPLETELY TERMINATE karके, loop ke BAAHAR nikal jaata hai. continue SIRF current ITERATION ko SKIP karके, loop ki NEXT iteration par CHALA jaata hai.

Pointer ek VARIABLE hai jo KISI DUSRE variable ka MEMORY ADDRESS STORE karta hai — normal variable VALUE store karta hai, pointer WOH VALUE KAHA hai, uska ADDRESS store karta hai.

& (address-of) operator KISI variable ka MEMORY ADDRESS deता hai. * (dereference) operator, POINTER ke ANDAR STORED address PAR JAKE, WAHA ki VALUE ACCESS karta hai.

Ek pointer jo KISI VALID memory address ko POINT NAHI karta — usse KOI object ASSIGN NAHI hua. NULL pointer ko DEREFERENCE karne ki KOSHISH karne se PROGRAM CRASH ho jaata hai (segmentation fault).

Pointer PAR +/- operations — jaise ptr+1, pointer ko NEXT element ke ADDRESS PAR MOVE karta hai (data type ki SIZE ke HISAAB se, EK BYTE NAHI, poore ELEMENT ki SIZE JITNA).

Array ka NAAM, USKE PEHLE ELEMENT ke ADDRESS mein AUTOMATICALLY DECAY (convert) ho jaata hai jab pointer CONTEXT mein use kiya jaaye — isliye arr[i] aur *(arr+i) EK HI CHEEZ hain.

Ek pointer jo KISI DUSRE pointer ka ADDRESS STORE karta hai (int **pp). Common use-case: FUNCTION ke ANDAR SE, EK POINTER ki VALUE ko MODIFY karna (jaise dynamic memory allocation functions mein).

Ek pointer jo EK FUNCTION ke ADDRESS ko STORE karta hai — isse FUNCTIONS ko VARIABLES ki tarah PASS/STORE kiya ja sakta hai, jaise callback functions implement karne ke liye.

Ek GENERIC pointer jo KISI BHI DATA TYPE ko POINT kar sakta hai — ISKO DEREFERENCE karne se PEHLE, SPECIFIC TYPE mein CAST karna ZAROORI hai, kyunki compiler ko VOID pointer ki TARGET TYPE ka PATA NAHI hota.

Stack LOCAL VARIABLES aur FUNCTION CALLS store karta hai — AUTOMATICALLY manage hota hai (fast, LIMITED size). Heap DYNAMICALLY allocated memory (malloc se) store karta hai — MANUALLY manage karna padta hai (bada, FLEXIBLE size).

malloc() SIRF memory ALLOCATE karta hai (garbage/uninitialized VALUES ke saath). calloc() memory ALLOCATE karke, usse ZERO se bhi INITIALIZE kar deta hai — thoda SLOWER, lekin SAFER.

malloc()/calloc() se ALLOCATED memory ko WAAPAS SYSTEM ko RETURN karta hai — agar free() NA kiya jaaye, MEMORY LEAK hoti hai (memory OCCUPIED rehti hai, chahe use ho ya na ho).

Jab DYNAMICALLY allocated memory ka REFERENCE (pointer) KHO jaata hai, BINA usse free() kiye — WOH memory PROGRAM ki POORI LIFETIME tak OCCUPIED rehti hai, chahe use ho ya na ho.

Ek pointer jo EK MEMORY LOCATION ko POINT karta hai jo ALREADY freed ho chuki hai (ya jiska SCOPE khatam ho gaya hai) — ISKO DEREFERENCE karna UNDEFINED BEHAVIOR deता hai.

PEHLE SE ALLOCATED memory block ka SIZE CHANGE karta hai (badाता ya GHATATA hai) — agar POSSIBLE ho, SAME location mein RESIZE karta hai, warna NAYI location mein COPY karके, PURANI ko FREE kar deta hai.

C mein STRING ek CHARACTER ARRAY hai, jo NULL CHARACTER ('\0') se TERMINATE hoti hai — ye NULL character BATATA hai ki STRING KAHA KHATAM hoti hai.

strlen() STRING ki ACTUAL LENGTH (NULL character ko EXCLUDE karके) COUNT karta hai, RUNTIME par. sizeof() ARRAY ki TOTAL ALLOCATED SIZE (NULL character SAHIT) deta hai, COMPILE-TIME par.

strcpy() STRING ko COPY karta hai, BINA DESTINATION BUFFER ki SIZE CHECK kiye (BUFFER OVERFLOW ka RISK). strncpy() EK MAXIMUM CHARACTER LIMIT specify karने deta hai — SAFER option hai.

DO STRINGS COMPARE karta hai — 0 agar EQUAL hain, NEGATIVE value agar FIRST string ALPHABETICALLY PEHLE aata hai, POSITIVE value agar BAAD mein aata hai.

Jab EK ARRAY/BUFFER mein, USKI ALLOCATED SIZE SE ZYAADA DATA WRITE kiya jaata hai — YE ADJACENT MEMORY ko CORRUPT kar sakta hai, aur EK MAJOR SECURITY VULNERABILITY hai.

Ek USER-DEFINED data type jo MULTIPLE, DIFFERENT data types ko EK SAATH, EK SINGLE UNIT ke roop mein GROUP karta hai — jaise ek "Student" struct mein naam (string), age (int), marks (float) SAATH mein.

Dot (.) operator DIRECT struct VARIABLE ke MEMBERS ACCESS karne ke liye use hota hai. Arrow (->) operator STRUCT POINTER ke THROUGH MEMBERS ACCESS karne ke liye use hota hai.

Struct mein, HAR MEMBER ki APNI SEPARATE MEMORY hoती hai (SAB ADD hoti hai). Union mein, SAARE MEMBERS SAME MEMORY LOCATION SHARE karte hain — ek WAQT mein SIRF EK MEMBER ki VALUE VALID hoती hai, isliye union struct se KAM MEMORY LETA hai.

Har baar "struct StructName variable;" LIKHNE ke BAJAYE, typedef se EK SHORTER ALIAS BANAYA ja sakta hai — jaise typedef struct {...} Student; ke BAAD, SIRF "Student variable;" LIKHNA KAAFI hai.

Ek STRUCT ke ANDAR, EK DUSRA STRUCT MEMBER ke roop mein DEFINE kiya jaana — jaise EK "Employee" struct mein EK "Address" struct EMBEDDED ho sakta hai.

Function ki DEFINITION se PEHLE, USKI SIGNATURE (return type, naam, parameters) BATANA — compiler ko main() se PEHLE HI PATA CHAL jaata hai FUNCTION KAISे CALL karna hai, chahe DEFINITION FILE mein BAAD mein aaye.

Pass by value mein, FUNCTION ko VARIABLE ki COPY milती hai (original UNCHANGED rehta hai). Pass by reference (C mein POINTERS ke THROUGH SIMULATE hota hai) mein, FUNCTION ORIGINAL variable ko DIRECTLY MODIFY kar sakta hai.

Recursion mein, FUNCTION KHUD KO CALL karta hai. Base case WOH CONDITION hai jaha RECURSION RUKTI hai — AGAR NA ho, STACK OVERFLOW (infinite calls) HO JAAYEGA.

Recursive solutions AKSAR MORE READABLE hote hain (SPECIALLY tree/graph problems ke liye), LEKIN FUNCTION CALL OVERHEAD (memory, TIME) ki wajah se, ITERATIVE solutions GENERALLY FASTER aur MEMORY-EFFICIENT hote hain.

Local variables EK FUNCTION ke ANDAR DEFINE hote hain, SIRF USI FUNCTION mein ACCESSIBLE hote hain. Global variables FUNCTIONS ke BAAHAR DEFINE hote hain, POORE PROGRAM mein ACCESSIBLE hote hain.

Static local variable SIRF EK BAAR INITIALIZE hota hai, aur ITS VALUE, FUNCTION CALLS ke BEECH, PRESERVE hoती hai (normal local variables HAR CALL par RESET ho jaate hain).

Ek SPECIAL pointer (FILE *) jo EK OPEN FILE ko REPRESENT karta hai — fopen() FUNCTION EK FILE OPEN karके, EK FILE POINTER RETURN karta hai, jo BAAKI SAARE file OPERATIONS mein use hota hai.

"r" (READ), "w" (WRITE, EXISTING content OVERWRITE), "a" (APPEND, END mein ADD), "r+"/"w+"/"a+" (READ+WRITE COMBINATIONS) — HAR MODE, FILE ke SAATH DIFFERENT BEHAVIOR DEFINE karta hai.

FILE ko CLOSE karके, OS RESOURCES (file HANDLES) FREE karta hai, aur ENSURE karta hai ki BUFFERED DATA (jo abhi tak ACTUAL FILE mein WRITE NAHI hua) PROPERLY FLUSH/SAVE ho jaaye.

BINARY DATA ko FILE se READ (fread) YA FILE mein WRITE (fwrite) karte hain — TEXT-based fscanf/fprintf ki TARAH NAHI, YE RAW BYTES ke SAATH KAAM karte hain, jaise STRUCTS ko DIRECTLY FILE mein SAVE karna.

COMPILATION SE PEHLE, SPECIFIED FILE (jaise stdio.h) ka CONTENT, CURRENT FILE mein "COPY-PASTE" kar deta hai — isliye HUM printf() jaisi FUNCTIONS use kar paate hain, JINKI DECLARATION stdio.h mein hoti hai.

EK SIMPLE TEXT-REPLACEMENT RULE — jaise #define PI 3.14159, COMPILATION SE PEHLE, POORE CODE mein "PI" ko "3.14159" SE REPLACE kar deta hai.

Macro COMPILE-TIME par TEXT REPLACEMENT hai (NO function CALL OVERHEAD, LEKIN NO TYPE CHECKING). Function RUNTIME par CALL hota hai (TYPE-SAFE, LEKIN THODA SLOWER FUNCTION-CALL OVERHEAD ki wajah se).

"INCLUDE GUARDS" HAIN — ENSURE karte hain ki EK HEADER FILE, EK HI COMPILATION mein, MULTIPLE TIMES INCLUDE HONE PAR bhi, SIRF EK BAAR PROCESS ho — DUPLICATE DEFINITIONS ke ERRORS AVOID karte hain.

STATIC arrays ki SIZE COMPILE-TIME PAR FIXED hoती hai. DYNAMIC allocation (malloc) se, RUNTIME PAR, DATA ki ACTUAL ZAROORAT ke HISAAB SE, MEMORY SIZE DECIDE ki ja sakti hai — FLEXIBLE, EFFICIENT.

INDIVIDUAL BITS PAR DIRECTLY OPERATIONS karne ke liye — LOW-LEVEL programming (EMBEDDED SYSTEMS, FLAGS, PERFORMANCE-CRITICAL code) mein COMMON, jaha MEMORY/SPEED CRITICAL hoती hai.

Ek VARIABLE (ya POINTER TARGET) ko IMMUTABLE (UNCHANGEABLE) MARK karta hai — AGAR COMPILER DEKHE KI const VARIABLE MODIFY HO RAHI HAI, COMPILE-TIME ERROR AATA HAI, ACCIDENTAL CHANGES SE BACHATA HAI.

EK DATA TYPE (ya VARIABLE) ki MEMORY SIZE, BYTES mein, RETURN karta hai — COMPILE-TIME PAR EVALUATE hota hai (RUNTIME FUNCTION CALL NAHI hai).

IMPLICIT casting AUTOMATICALLY hoti hai (jaise int KO float ASSIGN karte WAQT). EXPLICIT casting MANUALLY specify ki jaati hai (jaise (int)3.14) — PROGRAMMER SPECIFICALLY TYPE CONVERSION FORCE karta hai.

MULTIPLE EXPRESSIONS ko EK SAATH, LEFT-TO-RIGHT ORDER mein, EVALUATE karta hai — POORE EXPRESSION ki VALUE, SABSE RIGHT wale EXPRESSION ki VALUE hoti hai. COMMONLY for LOOPS mein MULTIPLE VARIABLES INITIALIZE/UPDATE karne ke liye USE hota hai.

EK ARRAY, JISKA HAR ELEMENT EK POINTER hai (NA KI EK NORMAL VALUE) — COMMON use-case: STRING ARRAYS (char *names[]), JAHA HAR ELEMENT, EK DIFFERENT STRING ko POINT karta hai.

const int *p — POINTER TARGET (VALUE) CHANGE NAHI ho sakti, POINTER KHUD REASSIGN ho sakta hai. int * const p — POINTER KHUD REASSIGN NAHI ho sakta, LEKIN VALUE JISKO WOH POINT karta hai, MODIFY ho sakti hai.

sizeof(array) POORI ARRAY ki SIZE DETA hai (ALL elements). sizeof(pointer) SIRF POINTER VARIABLE ki SIZE DETA hai (typically 4 YA 8 bytes) — YE EK COMMON CONFUSION/BUG SOURCE hai.

Jab PROGRAM KISI AISI MEMORY ko ACCESS KARNE KI KOSHISH KARTA HAI JISKA USE PERMISSION NAHI HAI — jaise NULL POINTER DEREFERENCE, YA FREED MEMORY ACCESS KARNA.

Valgrind SABSE POPULAR TOOL hai C/C++ mein MEMORY LEAKS, INVALID MEMORY ACCESS, aur UNINITIALIZED VARIABLES DETECT KARNE KE LIYE.

Jab EK HI POINTER PAR free() DO BAAR CALL KIYA JAATA HAI — YE UNDEFINED BEHAVIOR HAI, aur AKSAR PROGRAM CRASH YA MEMORY CORRUPTION KA CAUSE BANTA HAI.

String LITERAL (jaise "hello") READ-ONLY MEMORY MEIN STORE HOTA HAI (MODIFY KARNE KI KOSHISH UNDEFINED BEHAVIOR HAI). CHARACTER ARRAY (char arr[] = "hello") EK MUTABLE COPY BANATA HAI, JISE MODIFY KIYA JA SAKTA HAI.

DO STRINGS KO JOD (CONCATENATE) KARTA HAI. RISK: AGAR DESTINATION BUFFER MEIN ENOUGH SPACE NAHI HAI, BUFFER OVERFLOW HO SAKTA HAI — strncat() SAFER ALTERNATIVE HAI.

COMPILER, MEMORY ALIGNMENT KE LIYE, STRUCT MEMBERS KE BEECH EXTRA (UNUSED) BYTES ADD KAR DETA HAI — ISKI WAJAH SE sizeof(struct), INDIVIDUAL MEMBERS KE SIZES KE SUM SE BADA HO SAKTA HAI.

EK STRUCT JISME EK MEMBER, SAME STRUCT TYPE KA POINTER HOTA HAI — jaise LINKED LIST NODES (struct Node { int data; struct Node *next; };), TREES, aur OTHER DYNAMIC DATA STRUCTURES BANANE KE LIYE ESSENTIAL.

FUNCTIONS JO VARIABLE NUMBER OF ARGUMENTS ACCEPT KARTE HAIN — stdarg.h (va_list, va_start, va_arg) USE KARKE IMPLEMENT KIYE JAATE HAIN. printf() EK CLASSIC EXAMPLE HAI.

EK HINT COMPILER KO — FUNCTION CALL KE BAJAYE, FUNCTION KE BODY KO, CALL SITE PAR DIRECTLY "COPY-PASTE" KAR DO — FUNCTION-CALL OVERHEAD AVOID HOTA HAI, CHHOTE, FREQUENTLY-CALLED FUNCTIONS KE LIYE USEFUL.

EK RECURSIVE FUNCTION JISME RECURSIVE CALL, FUNCTION KA SABSE AAKHRI (LAST) OPERATION HAI — KUCH COMPILERS ISE OPTIMIZE KARKE, LOOP MEIN CONVERT KAR SAKTE HAIN, STACK OVERFLOW AVOID KARNE KE LIYE.

Text mode ("r"/"w") mein, OS KUCH CHARACTER TRANSLATIONS KARTA HAI (jaise newline HANDLING). Binary mode ("rb"/"wb") RAW BYTES KO, BINA KISI TRANSLATION KE, EXACTLY WAISE HI READ/WRITE KARTA HAI.

CHECK KARTA HAI KI FILE POINTER, FILE KE END TAK PAHUNCH CHUKA HAI YA NAHI — LOOPS MEIN COMMONLY USE HOTA HAI, FILE KO LINE-BY-LINE YA CHARACTER-BY-CHARACTER PADHNE KE LIYE.

DIFFERENT PLATFORMS/CONFIGURATIONS KE LIYE, DIFFERENT CODE COMPILE KARNE KE LIYE — jaise DEBUG BUILD MEIN EXTRA LOGGING CODE INCLUDE KARNA, PRODUCTION BUILD MEIN NAHI.

COMPILER-SPECIFIC INSTRUCTIONS DETA HAI (jaise #pragma once, HEADER GUARD KA SHORTHAND ALTERNATIVE) — YE STANDARD C NAHI HAI, COMPILER-DEPENDENT BEHAVIOR HAI.

COMPILER KO BATATA HAI KI EK VARIABLE, PROGRAM KE CONTROL KE BAAHAR (jaise HARDWARE, INTERRUPT) SE, KABHI BHI CHANGE HO SAKTI HAI — ISLIYE COMPILER USKO OPTIMIZE (CACHE) NA KARE, HAMESHA MEMORY SE DOBARA PADHE.

EK VARIABLE KI SCOPE, LIFETIME, aur VISIBILITY — auto (default, LOCAL), register (FAST ACCESS HINT), static (FUNCTION CALLS KE BEECH PRESERVE), extern (MULTIPLE FILES MEIN SHARE).

EK USER-DEFINED TYPE JO NAMED INTEGER CONSTANTS KA SET DEFINE KARTA HAI — jaise enum Day {MON, TUE, WED}; — CODE KO ZYAADA READABLE aur MAINTAINABLE BANATA HAI, MAGIC NUMBERS KE BAJAYE.

main(int argc, char *argv[]) — argc ARGUMENTS KI COUNT DETA HAI, argv EK ARRAY HAI JISME HAR ARGUMENT, EK STRING KE ROOP MEIN STORED HAI — PROGRAM KO TERMINAL SE INPUT LENE DETA HAI.

int matrix[3][4]; SE 3 ROWS AUR 4 COLUMNS KA GRID BANTA HAI — INTERNALLY, YE MEMORY MEIN EK CONTIGUOUS, ROW-MAJOR ORDER MEIN STORED HOTA HAI.

EK OPERATION JISKA RESULT, C STANDARD KE HISAAB SE, PREDICTABLE NAHI HAI — jaise UNINITIALIZED VARIABLE USE KARNA, YA ARRAY BOUNDS SE BAAHAR ACCESS KARNA — DIFFERENT COMPILERS/RUNS PAR, DIFFERENT (YA CRASH-CAUSING) BEHAVIOR DE SAKTA HAI.

Header file (.h) DECLARATIONS (function PROTOTYPES, STRUCT DEFINITIONS) CONTAIN KARTI HAI. Source file (.c) ACTUAL IMPLEMENTATION (function BODIES) CONTAIN KARTI HAI — YE SEPARATION, CODE ORGANIZATION aur REUSABILITY IMPROVE KARTA HAI.

COMPILER, HAR .c FILE KO SEPARATELY, OBJECT FILES (.o) MEIN COMPILE KARTA HAI. LINKER, IN SAARI OBJECT FILES KO, aur LIBRARY FUNCTIONS KO, EK SAATH JODKAR, EK FINAL EXECUTABLE BANATA HAI.

Global variables, POORE PROGRAM MEIN, KAHI SE BHI MODIFY HO SAKTE HAIN — ISSE CODE KO TRACE/DEBUG KARNA MUSHKIL HO JAATA HAI, aur UNEXPECTED SIDE EFFECTS KA RISK BADH JAATA HAI.

C EK LOW-LEVEL, MINIMALIST LANGUAGE HAI — ERROR HANDLING TYPICALLY RETURN VALUES (jaise NULL, -1) aur errno GLOBAL VARIABLE KE THROUGH MANUALLY CHECK KI JAATI HAI, TRY-CATCH JAISA BUILT-IN MECHANISM NAHI HAI.

HAR CHARACTER, INTERNALLY, EK NUMBER (ASCII CODE) KE ROOP MEIN STORED HOTA HAI — jaise 'A' = 65, 'a' = 97. ISLIYE char, EK CHHOTA INTEGER TYPE (1 byte) BHI HAI, aur ARITHMETIC OPERATIONS (jaise 'A'+1) POSSIBLE HAIN.