Code10x

C ek PROCEDURAL language hai (functions-based). C++ USI PAR BUILT hai, LEKIN OBJECT-ORIENTED PROGRAMMING (classes, objects, inheritance) bhi SUPPORT karta hai — isliye C++ ko "C WITH CLASSES" bhi kaha jaata hai.

cout (character output) CONSOLE PAR OUTPUT PRINT karta hai (<< operator SE). cin (character input) USER SE INPUT LETA hai (>> operator SE) — C ke printf/scanf ka C++ EQUIVALENT.

Namespace, NAMES (variables, functions) ko LOGICALLY GROUP karके, NAMING CONFLICTS AVOID karta hai. "using namespace std" C++ Standard Library ke SAARE NAMES ko DIRECTLY, BINA std:: PREFIX ke, ACCESSIBLE bana deta hai.

Ek ALIAS (DUSRA NAAM) EK EXISTING variable ke liye (int &ref = x;) — pointer ki TARAH, LEKIN REASSIGN NAHI ho sakta, aur DEREFERENCE OPERATOR (*) ki zaroorat NAHI PADTI.

Pointer NULL ho sakta hai, REASSIGN ho sakta hai, EXPLICIT DEREFERENCING (*) CHAHIYE. Reference NULL NAHI ho sakta, EK BAAR SET hone ke BAAD REASSIGN NAHI ho sakta, aur NORMAL VARIABLE ki TARAH USE hota hai.

Function parameters ki DEFAULT VALUES, jo TAB USE hoती hain jab CALLER USE VALUE PROVIDE NA KARE — jaise void greet(string name = "Guest") {...}, greet() call karne par "Guest" USE HOGA.

SAME function NAAM, DIFFERENT PARAMETERS (number/type) KE SAATH, MULTIPLE BAAR DEFINE KIYA JA SAKTA HAI — compiler, CALL KE PARAMETERS DEKH KAR, CORRECT VERSION CHOOSE karta hai (compile-time).

EK HINT compiler KO — FUNCTION CALL KE BAJAYE, FUNCTION KI BODY, CALL SITE PAR DIRECTLY COPY-PASTE KAR DO — FUNCTION-CALL OVERHEAD AVOID hota hai, CHHOTE, FREQUENTLY-CALLED functions KE LIYE.

Compiler ko AUTOMATICALLY, INITIALIZATION VALUE SE, VARIABLE KA TYPE DEDUCE (samajh) karne DETA HAI — jaise auto x = 5; (x AUTOMATICALLY int BAN JAATA HAI). CODE KO CONCISE BANATA HAI.

Class EK BLUEPRINT/TEMPLATE hai (DEFINE karti hai KYA FIELDS/METHODS HONGE). Object, CLASS KA EK ACTUAL, REAL INSTANCE hai, JISKI APNI VALUES HOTI HAIN.

Class MEMBERS KI VISIBILITY — public (KAHI SE BHI ACCESSIBLE), private (SIRF CLASS KE ANDAR SE), protected (CLASS AUR USKI DERIVED CLASSES SE).

EK SPECIAL METHOD, CLASS KE NAAM JAISA, JO OBJECT BANTE HI (new/DECLARATION KE WAQT) AUTOMATICALLY CALL HOTA HAI — INITIAL VALUES SET KARNE KE LIYE.

EK SPECIAL METHOD (~ClassName()), JO OBJECT DESTROY HOTE WAQT AUTOMATICALLY CALL HOTA HAI — CLEANUP (jaise DYNAMICALLY allocated MEMORY FREE karna) KE LIYE USE hota hai.

EK CONSTRUCTOR JO EK NAYA OBJECT, EK EXISTING OBJECT KI COPY BANAKE, CREATE karta hai — jaise ClassName obj2 = obj1; YA ClassName obj2(obj1);

EK IMPLICIT pointer JO CURRENT OBJECT KO REFER karta hai — CLASS KE ANDAR SE, KISI MEMBER FUNCTION KE ANDAR, this->member SE, CURRENT OBJECT KE MEMBERS ACCESS KIYE JA SAKTE HAIN.

Static member, CLASS KA hota hai, KISI SPECIFIC OBJECT KA NAHI — SAARE OBJECTS ISE SHARE karte hain. ClassName::member SE, OBJECT BANAYE BINA BHI ACCESS KIYA JA SAKTA HAI.

EK FUNCTION JO CLASS KA MEMBER NAHI HAI, LEKIN CLASS KE PRIVATE/PROTECTED MEMBERS KO ACCESS KARNE KI PERMISSION RAKHTA HAI — friend KEYWORD SE DECLARE HOTA HAI.

CODE REUSABILITY — COMMON PROPERTIES/BEHAVIOR EK PARENT (BASE) CLASS MEIN LIKH KAR, CHILD (DERIVED) CLASSES USE REUSE KAR SAKTI HAIN, BINA DOBARA LIKHE.

Single = EK PARENT SE EK CHILD. Multiple = EK CHILD, MULTIPLE PARENTS SE INHERIT karta hai. Multilevel = EK CHAIN (A → B → C), JAHA B, A SE inherit karta hai, aur C, B SE.

EK BASE CLASS FUNCTION, JISE virtual KEYWORD SE MARK KIYA JAATA HAI, TAAKI DERIVED CLASS MEIN OVERRIDE HONE PAR, RUNTIME PAR, CORRECT (DERIVED) VERSION CALL HO — RUN-TIME POLYMORPHISM ENABLE karta hai.

EK VIRTUAL FUNCTION JISKI BODY NAHI HAI (virtual void func() = 0;) — AISI CLASS, JISME KAM SE KAM EK PURE VIRTUAL FUNCTION HO, "ABSTRACT" BAN JAATI HAI, DIRECTLY INSTANTIATE NAHI HO SAKTI.

Overloading SAME CLASS MEIN, SAME NAAM, DIFFERENT PARAMETERS (COMPILE-TIME polymorphism). Overriding PARENT-CHILD MEIN, SAME SIGNATURE, DIFFERENT IMPLEMENTATION (RUN-TIME polymorphism, virtual KE SAATH).

Jab EK CLASS, DO PARENTS SE INHERIT karti hai, JO KHUD, EK COMMON ANCESTOR SE INHERIT karte hain — AMBIGUITY HO JAATI HAI KI COMMON ANCESTOR KI COPY KAUN SI USE HO. virtual inheritance SE SOLVE hota hai.

AGAR BASE CLASS KA DESTRUCTOR virtual NAHI HAI, aur EK DERIVED OBJECT, BASE POINTER SE delete KIYA JAAYE, TO SIRF BASE DESTRUCTOR CALL HOGA, DERIVED PART LEAK HO SAKTA HAI.

Compile-time (STATIC): overloading, TEMPLATES — DECISION COMPILE KE WAQT HOTA HAI. Run-time (DYNAMIC): virtual functions KE SAATH OVERRIDING — DECISION RUNTIME PAR HOTA HAI, ACTUAL OBJECT TYPE KE HISAAB SE.

EXISTING OPERATORS (+, -, ==, etc.) KO, CUSTOM CLASSES KE LIYE, CUSTOM BEHAVIOR DENA — jaise DO Point OBJECTS KO + SE ADD KARNA, jaisa NUMBERS KE SAATH HOTA HAI.

SCOPE RESOLUTION (::), MEMBER ACCESS (.), TERNARY (?:), aur sizeof — YE C++ MEIN OVERLOAD KARNE KI PERMISSION NAHI HAI.

Member function TAB, JAB LEFT OPERAND HAMESHA CLASS KA OBJECT HO. Friend function TAB, JAB LEFT OPERAND CLASS KA OBJECT NA HO (jaise cout << obj, JAHA cout OSTREAM HAI).

DEFAULT assignment, SHALLOW COPY karta hai (POINTERS COPY hote hain, DATA NAHI) — AGAR CLASS MEIN DYNAMICALLY ALLOCATED MEMORY HAI, CUSTOM = OPERATOR SE DEEP COPY IMPLEMENT KARNA ZAROORI HAI.

EK BLUEPRINT JO GENERIC, TYPE-INDEPENDENT CODE LIKHNE DETA HAI — SAME FUNCTION/CLASS, MULTIPLE DATA TYPES (int, float, string) KE SAATH, BINA DOBARA LIKHE, KAAM KAR SAKTA HAI.

Function template EK GENERIC FUNCTION DEFINE karta hai (jaise template<typename T> T max(T a, T b)). Class template EK GENERIC CLASS DEFINE karta hai (jaise vector<T>, JAHA T KOI BHI TYPE HO SAKTA HAI).

EK SPECIFIC DATA TYPE KE LIYE, TEMPLATE KA EK CUSTOM, DIFFERENT IMPLEMENTATION DENA — jaise GENERAL template SAARE TYPES KE LIYE, LEKIN char* KE LIYE EK SPECIAL VERSION.

C++ KI BUILT-IN LIBRARY JO READY-MADE, GENERIC DATA STRUCTURES (vector, map, set) aur ALGORITHMS (sort, find) PROVIDE karti hai — COMMON DATA STRUCTURES MANUALLY IMPLEMENT KARNE KI ZAROORAT NAHI.

Array KA SIZE FIXED HOTA HAI (COMPILE-TIME). vector DYNAMICALLY RESIZE HO SAKTA HAI (RUNTIME PAR ELEMENTS ADD/REMOVE) — MOST COMMON STL CONTAINER HAI.

map, KEYS KO SORTED ORDER MEIN RAKHTA HAI (RED-BLACK TREE, O(log n) OPERATIONS). unordered_map, HASH TABLE USE karta hai (AVERAGE O(1) OPERATIONS, LEKIN ORDER GUARANTEE NAHI).

EK OBJECT JO CONTAINER (vector, map, etc.) KE ELEMENTS KO, EK-EK KARKE, TRAVERSE KARNE DETA HAI — POINTER KI TARAH BEHAVE karta hai (begin(), end() SE USE HOTA HAI).

try BLOCK MEIN RISKY CODE LIKHTE HAIN. AGAR ERROR (EXCEPTION) AAYE, throw SE USE "PHENKA" JAATA HAI, aur MATCHING catch BLOCK USE HANDLE karta hai.

C++ STANDARD LIBRARY, PRE-DEFINED EXCEPTION CLASSES DETI HAI (std::exception HIERARCHY MEIN) — jaise std::out_of_range, std::invalid_argument — COMMON ERROR SCENARIOS KE LIYE READY-MADE.

EK "CATCH-ALL" BLOCK JO KISI BHI TYPE KI EXCEPTION KO CATCH KAR LETA HAI, CHAHE USKA EXACT TYPE PATA HO YA NA HO — SAFETY NET KE ROOP MEIN, LAST catch BLOCK KE ROOP MEIN USE HOTA HAI.

new HEAP PAR DYNAMICALLY MEMORY ALLOCATE karta hai (malloc KA C++ EQUIVALENT, LEKIN CONSTRUCTOR BHI CALL KARTA HAI). delete WOH MEMORY FREE karta hai (DESTRUCTOR CALL KARKE).

Smart pointers (unique_ptr, shared_ptr) AUTOMATICALLY MEMORY MANAGE karte hain — JAB POINTER SCOPE SE BAAHAR JAATA HAI, MEMORY AUTOMATICALLY free HO JAATI HAI, MANUAL delete KI ZAROORAT NAHI, MEMORY LEAKS AVOID HOTE HAIN.

unique_ptr, EK RESOURCE KA SIRF EK OWNER RAKHTA HAI (COPY NAHI HO SAKTA, SIRF MOVE). shared_ptr, MULTIPLE OWNERS ALLOW karta hai (REFERENCE COUNTING SE, JAB LAST OWNER KHATAM HOTA HAI, MEMORY FREE HOTI HAI).

EK C++ DESIGN PRINCIPLE — RESOURCE (memory, file handle) KO OBJECT KE CONSTRUCTOR MEIN ACQUIRE KARNA, aur DESTRUCTOR MEIN AUTOMATICALLY RELEASE KARNA — smart pointers ISI PRINCIPLE PAR BANE HAIN.

EK ANONYMOUS (NAAM-LESS) FUNCTION, INLINE DEFINE KIYA JAATA HAI — jaise auto add = [](int a, int b) { return a + b; }; — CALLBACKS, SHORT OPERATIONS KE LIYE USEFUL.

EK VARIABLE (YA MEMBER FUNCTION) KO IMMUTABLE MARK KARTA HAI — AGAR MODIFY KARNE KI KOSHISH HO, COMPILE-TIME ERROR AATA HAI, ACCIDENTAL CHANGES SE BACHATA HAI.

EK OBJECT KE RESOURCES KO, EXPENSIVE COPY KARNE KE BAJAYE, EK DUSRE OBJECT MEIN "MOVE" (TRANSFER) KARNA — TEMPORARY OBJECTS KE LIYE PERFORMANCE SIGNIFICANTLY IMPROVE KARTA HAI.

C++11 MEIN INTRODUCE KIYA GAYA, TYPE-SAFE NULL POINTER — PURANA NULL (JO ACTUALLY 0 THA) KABHI-KABHI INTEGER SE CONFUSE HO JAATA THA OVERLOAD RESOLUTION MEIN, nullptr YE AMBIGUITY REMOVE KARTA HAI.

Libraries JISME POORA IMPLEMENTATION, .h/.hpp FILES MEIN HI HOTA HAI (SEPARATE .cpp FILE COMPILE KARNE KI ZAROORAT NAHI) — jaise EIGEN — SIRF #include KARNE SE USE HO JAATI HAIN.

Preprocessing (macros, includes RESOLVE) → Compilation (source CODE, ASSEMBLY/OBJECT CODE MEIN CONVERT) → Linking (MULTIPLE OBJECT FILES + LIBRARIES, EK EXECUTABLE MEIN COMBINE).

EK OPERATION JISKA RESULT, C++ STANDARD KE HISAAB SE, PREDICTABLE NAHI HAI — jaise ARRAY BOUNDS SE BAAHAR ACCESS, UNINITIALIZED VARIABLE USE — DIFFERENT COMPILERS/RUNS PAR, DIFFERENT BEHAVIOR DE SAKTA HAI.

NULL, C SE INHERITED, TYPICALLY 0 (INTEGER) HOTA HAI. nullptr, C++11 KA TYPE-SAFE POINTER LITERAL HAI — OVERLOAD RESOLUTION AMBIGUITIES AVOID KARTA HAI.

EK SIMPLIFIED LOOP SYNTAX — for (int x : container) { ... } — CONTAINER KE HAR ELEMENT KO, MANUALLY INDEX/ITERATOR MANAGE KIYE BINA, TRAVERSE KARNE DETA HAI.

constexpr GUARANTEE KARTA HAI KI VALUE, COMPILE-TIME PAR HI EVALUATE HO JAAYE (PERFORMANCE optimization). const SIRF IMMUTABILITY GUARANTEE KARTA HAI, VALUE RUNTIME PAR BHI SET HO SAKTI HAI.

DATA (fields) KO private RAKH KAR, aur public GETTER/SETTER METHODS SE CONTROLLED ACCESS DEKAR — DATA SAFE RAHTA HAI, GALTI SE BAAHAR SE DIRECTLY CHANGE NAHI HOTA.

C++ MEIN "INTERFACE" KOI SEPARATE KEYWORD NAHI HAI — EK CLASS, JISKE SAARE METHODS PURE VIRTUAL HAIN (KOI IMPLEMENTATION NAHI), EK "INTERFACE" KI TARAH BEHAVE KARTI HAI.

ClassName(int x) : member(x) {} SYNTAX — MEMBERS KO, CONSTRUCTOR BODY MEIN ASSIGN KARNE KE BAJAYE, DIRECTLY INITIALIZE KARTA HAI — MORE EFFICIENT (EXTRA ASSIGNMENT STEP AVOID), aur const/REFERENCE MEMBERS KE LIYE ZAROORI HAI.

Private members SIRF SAME CLASS KE ANDAR SE ACCESSIBLE HAIN. Protected members, SAME CLASS KE ANDAR SE, AUR DERIVED (CHILD) CLASSES SE BHI ACCESSIBLE HAIN.

AGAR DERIVED CLASS, BASE CLASS KE SAME-NAAM FUNCTION KO, virtual KE BINA, REDEFINE KAR DE, TO BASE VERSION "HIDE" HO JAATA HAI (OVERRIDE NAHI, HIDE) — POLYMORPHISM CORRECTLY KAAM NAHI KARTA.

EXPLICITLY BATATA HAI KI EK METHOD, BASE CLASS KE virtual METHOD KO OVERRIDE KARNE KA IRADA RAKHTA HAI — AGAR SIGNATURE MATCH NA HO (TYPO KI WAJAH SE), COMPILE-TIME ERROR AATA HAI, SILENT BUG NAHI.

CUSTOM CLASS KO, cout << obj SYNTAX SE, DIRECTLY PRINT KARNE KI PERMISSION DENA — ostream& operator<<(ostream& os, const ClassName& obj) SE IMPLEMENT HOTA HAI.

DEFAULT ==, MEMORY ADDRESS COMPARE KARTA HAI. OVERLOAD KARNE SE, DO OBJECTS KI "LOGICAL EQUALITY" (jaise SAME NAME/ID) COMPARE KI JA SAKTI HAI, jaise EK Point(x,y) KE COORDINATES COMPARE KARNA.

Templates JO VARIABLE NUMBER OF ARGUMENTS ACCEPT KAR SAKTE HAIN — jaise EK print() FUNCTION JO 1, 2, YA 10 ARGUMENTS, KISI BHI TYPE KE, ACCEPT KAR SAKE.

COMPILE-TIME PAR, TEMPLATES KE THROUGH, COMPUTATIONS KARNA (RUNTIME PAR NAHI) — ADVANCED TECHNIQUE, PERFORMANCE-CRITICAL LIBRARIES MEIN USE HOTI HAI.

set, UNIQUE VALUES KO SORTED ORDER MEIN RAKHTA HAI. unordered_set, HASH-BASED HAI, ORDER GUARANTEE NAHI, LEKIN AVERAGE O(1) OPERATIONS DETA HAI.

pair EXACTLY DO VALUES (POSSIBLY DIFFERENT TYPES) STORE KARTA HAI. tuple, KISI BHI NUMBER OF VALUES (DIFFERENT TYPES) STORE KAR SAKTA HAI.

READY-MADE, WELL-TESTED, OPTIMIZED IMPLEMENTATIONS — MANUALLY SORTING/SEARCHING ALGORITHMS LIKHNE KI ZAROORAT NAHI, aur YE ITERATORS KE SAATH, KISI BHI CONTAINER PAR KAAM KARTE HAIN.

Jab EK EXCEPTION THROW HOTI HAI, PROGRAM, CALL STACK KO "UNWIND" KARTA HAI (FUNCTION CALLS KO REVERSE ORDER MEIN EXIT KARTA HAI), HAR LEVEL PAR LOCAL OBJECTS KE DESTRUCTORS CALL KARTA HAI, JAB TAK MATCHING catch NA MILE.

EK FUNCTION KO MARK KARTA HAI KI WOH KOI EXCEPTION THROW NAHI KAREGA — COMPILER, PERFORMANCE OPTIMIZATIONS KAR SAKTA HAI, aur AGAR FUNCTION ACTUALLY THROW KARE, PROGRAM std::terminate() CALL KARTA HAI.

Jab new SE ALLOCATED memory, delete KIYE BINA, "KHO" JAATI HAI (REFERENCE LOST HO JAATA HAI) — WOH MEMORY, PROGRAM KI POORI LIFETIME TAK, OCCUPIED RAHTI HAI.

EK NON-OWNING SMART POINTER JO shared_ptr KE SAATH USE HOTA HAI — CIRCULAR REFERENCES (DO OBJECTS EK DUSRE KO shared_ptr SE REFER KAREIN) SE HONE WALE MEMORY LEAKS AVOID KARTA HAI.

Shallow copy, POINTERS KO COPY KARTA HAI (DONO OBJECTS, SAME MEMORY KO POINT KARTE HAIN — RISKY). Deep copy, ACTUAL DATA KI NAYI COPY BANATA HAI (INDEPENDENT MEMORY) — SAFER, LEKIN SLOWER.

EK SYNTAX JO, EK pair/tuple/struct KO, MULTIPLE VARIABLES MEIN, EK LINE MEIN, DIRECTLY UNPACK KARNE DETA HAI — jaise auto [x, y] = getCoordinates();

EK WRAPPER TYPE JO "VALUE HO SAKTI HAI, YA NAHI BHI" REPRESENT KARTA HAI — NULL POINTER YA SPECIAL SENTINEL VALUES (jaise -1) KE BAJAYE, EXPLICITLY, TYPE-SAFE TAREEKE SE "ABSENCE" REPRESENT KARTA HAI.

C++ CODE KO, C LIBRARIES KE SAATH INTEROPERATE KARNE DETA HAI — C++ KA "NAME MANGLING" (function names ko COMPILE-TIME PAR MODIFY KARNA) DISABLE KARTA HAI, TAAKI C LINKER, FUNCTIONS KO SAHI SE PEHCHAN SAKE.

Static binding (COMPILE-TIME): FUNCTION CALL, COMPILE TIME PAR HI RESOLVE HO JAATA HAI (NORMAL functions, OVERLOADING). Dynamic binding (RUNTIME): virtual FUNCTIONS KE SAATH, ACTUAL OBJECT TYPE KE HISAAB SE, RUNTIME PAR RESOLVE HOTA HAI.

Jab EK DERIVED CLASS OBJECT, EK BASE CLASS OBJECT (POINTER/REFERENCE NAHI) MEIN ASSIGN KIYA JAATA HAI, DERIVED-SPECIFIC PARTS "SLICE" (CUT) HO JAATE HAIN — SIRF BASE PART BACHTA HAI.

HAR .cpp FILE, EK SEPARATE "COMPILATION UNIT" HAI, INDEPENDENTLY COMPILE HOTI HAI — LARGE PROJECTS MEIN, CODE KO ORGANIZE KARTA HAI, aur INCREMENTAL COMPILATION (SIRF CHANGED FILES REBUILD) FASTER BANATA HAI.

AGAR EK CLASS, CUSTOM DESTRUCTOR, COPY CONSTRUCTOR, YA COPY ASSIGNMENT OPERATOR (KOI EK) DEFINE KARTI HAI, TO USE, TEENO (YA MOVE CONSTRUCTOR/ASSIGNMENT SAHIT PAANCH) DEFINE KARNE CHAHIYE — RESOURCE MANAGEMENT SAHI SE HANDLE KARNE KE LIYE.

EK EXPRESSION KA TYPE, COMPILE-TIME PAR, DETERMINE KARTA HAI — auto SE DIFFERENT, decltype VALUE KO EVALUATE NAHI KARTA, SIRF USKA TYPE NIKALTA HAI — TEMPLATE PROGRAMMING MEIN USEFUL.

EK OBJECT KO "RVALUE REFERENCE" MEIN CAST KARTA HAI, COMPILER KO SIGNAL KARTA HAI KI OBJECT KI RESOURCES "MOVE" KI JA SAKTI HAIN (COPY KI ZAROORAT NAHI) — MOVE SEMANTICS ENABLE KARTA HAI.

#include, HEADER FILE KA CONTENT, CURRENT FILE MEIN COPY KARTA HAI (COMPILATION SE PEHLE). #define, TEXT-REPLACEMENT MACROS DEFINE KARTA HAI — MODERN C++ MEIN, constexpr/inline functions, #define SE ZYAADA PREFER KIYE JAATE HAIN.