🔴 Advanced · Lesson 49

Best Practices

Best practices क्यों मायने रखते हैं

C आपको बहुत शक्ति और बहुत कम सुरक्षा-रेलिंग देता है। यही स्वतंत्रता C को तेज़ बनाती है — पर इसका मतलब यह भी है कि छोटी आदतें तय करती हैं कि आपका code ठोस है या छिपे bugs से भरा। Best practices वे आदतें हैं जो अनुभवी C programmers धीमे हुए बिना सुरक्षित रहने को इस्तेमाल करते हैं।

इनमें से कोई कठिन नहीं। ये छोटे, सुसंगत चुनाव हैं जो मिलकर साफ़, भरोसेमंद programs बनाते हैं।

Naming और style

ऐसे नाम इस्तेमाल करें जो बताएँ कि वे क्या हैं: totalMarks, न कि tm या x।
सुसंगत रहें — एक style चुनें (जैसे snake_case) और उसी पर टिके रहें।
सुसंगत indent करें और spaces इस्तेमाल करें ताकि blocks आसानी से दिखें।
छोटे comments लिखें जो क्यों समझाएँ, न कि जो code स्पष्ट रूप से करता है।

Before → After

int f(int a){int r=1;for(int i=1;i<=a;i++)r*=i;return r;} // aspasht

int factorial(int n) {          // saaf naam, padhne yogya
    int result = 1;
    for (int i = 1; i <= n; i++)
        result *= i;
    return result;
}

Memory safety

यहीं ज़्यादातर गंभीर C bugs रहते हैं। तीन नियम लगभग सबको रोकते हैं:

Pointer इस्तेमाल करने से पहले malloc/calloc को NULL के लिए हमेशा जाँचें।
काम पूरा होने पर हर block को ठीक एक बार free करें।
Free करने के बाद pointer को NULL करें ताकि गलती से इस्तेमाल न हो।

C Language

int *p = malloc(n * sizeof(int));
if (p == NULL) return 1;     // jaanchein
// ... p istemaal karein ...
free(p);                      // ek baar free
p = NULL;                     // dangling pointer se bachein

पूरी तस्वीर के लिए देखें C में dynamic memory।

Function design

हर function को एक साफ़ काम करना चाहिए।
इन्हें छोटा रखें — अगर screen पर न समाए, बाँटने पर विचार करें।
बहुत सारे global variables के बजाय parameters और return values इस्तेमाल करें।
Files के बीच साझा करते समय functions को header file में prototypes दें।

आम जाल से बचना

Variables initialise करें — uninitialised value garbage होती है।
Array bounds के अंदर रहें — index 0 से size − 1 तक ही।
Conditions में तुलना के लिए == इस्तेमाल करें, = (assignment) नहीं।
हर printf format specifier को उसके argument type से मिलाएँ।

⚠️ Classic bug

if (x = 5) 5 assign करता है और हमेशा true होता है। आपका मतलब लगभग हमेशा if (x == 5) था। इसे पकड़ने को compiler warnings (-Wall) चालू करें।

एक झटपट checklist

जाँच	क्यों
`-Wall` से compile किया?	Warnings असली bugs जल्दी पकड़ते हैं
सभी variables initialise?	Garbage values टालता है
`malloc` NULL के लिए जाँचा?	Crashes रोकता है
हर `malloc` का एक `free`?	कोई memory leak नहीं
Array indexes range में?	कोई out-of-bounds bug नहीं

🏋️ अभ्यास

अपना कोई पुराना program लें और इस checklist के हिसाब से सुधारें: अस्पष्ट variables rename करें, malloc checks जोड़ें, सब free करें, और -Wall से compile करके देखें कौन-सी warnings आती हैं।

सारांश

Best practices छोटी आदतें हैं जो C code को साफ़ और सुरक्षित रखती हैं।
साफ़ नाम, सुसंगत style और छोटे केंद्रित functions इस्तेमाल करें।
malloc जाँचें, एक बार free करें, और बाद में pointer null करें।
Variables initialise करें और array bounds के अंदर रहें।
Bugs जल्दी पकड़ने को warnings चालू (-Wall) रखकर compile करें।

अक्सर पूछे जाने वाले प्रश्न (FAQ)

C programming में सबसे ज़रूरी best practices क्या हैं?

मुख्य बातें: साफ़ नाम इस्तेमाल करें, functions छोटे और केंद्रित रखें, malloc और fopen जैसे functions की return value हमेशा जाँचें, जो allocate करें उसे free करें, इस्तेमाल से पहले variables initialise करें, और undefined behaviour जैसे uninitialised memory पढ़ना या array bounds से बाहर जाना टालें।

C में memory safety इतनी ज़रूरी क्यों है?

क्योंकि C आपके लिए memory प्रबंधित नहीं करता। Free हुई memory इस्तेमाल करना, array bounds के पार जाना, या free भूलना जैसी गलतियाँ crashes, security holes और leaks देती हैं। सावधान allocation, जाँच और freeing ही C programs को स्थिर रखता है।

C में undefined behaviour क्या है?

Undefined behaviour वह code है जिसका परिणाम C standard परिभाषित नहीं करता — जैसे uninitialised variable पढ़ना, zero से भाग, या array bounds से बाहर पहुँच। Program चल सकता है, crash हो सकता है, या garbage दे सकता है, इसलिए जो होता है उस पर निर्भर रहने के बजाय इन स्थितियों से बचें।

C function कितना लंबा होना चाहिए?

अच्छा function एक साफ़ काम करता है और आमतौर पर एक नज़र में पढ़ने लायक छोटा होता है — अक्सर लगभग 30 lines से कम। अगर function बड़ा हो जाए या कई असंबंधित काम करे, उसे छोटे functions में बाँटना code को पढ़ना, test करना और दोबारा इस्तेमाल करना आसान बनाता है।

क्या मुझे C में हमेशा variables initialise करने चाहिए?

हाँ। Uninitialised local variable garbage value रखता है, और उसे इस्तेमाल करना undefined behaviour है जो अप्रत्याशित bugs देता है। Declare करते समय हर variable को समझदार शुरुआती value देना कठिन-से-पकड़ने वाली errors की पूरी श्रेणी रोकता है।

← Back to C Tutorial