C++ में शुरुआती लोगों की 10 गलतियाँ: कोड कैसे न तोड़ें

C++ अनुभवी लोगों को भी क्यों तोड़ देता है, और शुरुआती लोगों को तो और भी ज्यादा

C++ एक निर्दयी भाषा है। यह आपको मेमोरी पर पूर्ण नियंत्रण देता है, लेकिन पूर्ण अनुशासन की भी मांग करता है। यदि आप अभी C++ सीखना शुरू कर रहे हैं, तो निश्चित रूप से आप पहले ही इस स्थिति का सामना कर चुके होंगे जहां प्रोग्राम कंपाइल हो जाता है, लेकिन एरर के साथ क्रैश हो जाता है, या (जो और भी बुरा है) बिना किसी एरर के गलत तरीके से काम करता है। यह आपकी गलती नहीं है - यह भाषा की प्रकृति है। लेकिन हम आपको उन सबसे सामान्य गड्ढों से बचने में मदद कर सकते हैं जिनमें सभी शुरुआती गिरते हैं।

इस लेख में हम C++ सीखते समय 10 गंभीर गलतियों का विश्लेषण करेंगे, जो कोड को मेमोरी लीक और अनिर्धारित व्यवहार के नारकीय मिश्रण में बदल देती हैं। चलिए शुरू करते हैं!

1. मेमोरी डिलीट करना भूल गए: क्लासिक लीक

C++ में शुरुआती लोगों की सबसे आम गलती - new के माध्यम से डायनामिक मेमोरी आवंटित करना और delete को भूल जाना। प्रोग्राम वैक्यूम क्लीनर की तरह RAM खाता है, और आपको पता भी नहीं चलता।

खराब उदाहरण:

int* ptr = new int(42);\n// ... बहुत सारा कोड ...\n// भूल गए: delete ptr;

परिणाम: मेमोरी लीक। प्रोग्राम चलता है, लेकिन हर कॉल के साथ अधिक से अधिक संसाधनों की खपत करता है। आधुनिक प्रोजेक्ट्स में यह अस्वीकार्य है।

कैसे ठीक करें:

\n
• स्मार्ट पॉइंटर्स (std::unique_ptr, std::shared_ptr) का उपयोग करें - वे स्वचालित रूप से मेमोरी साफ करते हैं।
\n
• यदि new/delete के बिना कोई रास्ता नहीं है - तो अंतिम उपयोग के तुरंत बाद हमेशा delete लगाएं।
\n

#include <memory>\nstd::unique_ptr<int> ptr = std::make_unique<int>(42);\n// स्कोप से बाहर निकलने पर मेमोरी स्वचालित रूप से मुक्त हो जाएगी

2. ग्लोबल स्कोप में using namespace std; का उपयोग

यह लाइन एक टाइम बम की तरह है। छोटे शैक्षिक उदाहरणों पर यह काम करती है, लेकिन वास्तविक प्रोजेक्ट में यह नामों के टकराव का कारण बनती है।

समस्या:

#include <iostream>\n#include <vector>\nusing namespace std;\n\n// एक साल बाद प्रोजेक्ट में अपना vector क्लास आ जाता है\nclass vector { ... }; // कंपाइलेशन एरर!

std (जैसे vector, cout) के नाम ग्लोबल हो जाते हैं, और समान नाम वाला आपका कोई भी क्लास टकराव पैदा करेगा।

बेहतर तरीका:

\n
• std::cout, std::vector स्पष्ट रूप से लिखें।
\n
• या केवल विशिष्ट नामों के लिए using std::cout; का उपयोग करें।
\n

3. अनिर्धारित व्यवहार: खुद को गोली मारना

C++ सीखते समय सबसे कपटी गलती अनिर्धारित व्यवहार (UB - Undefined Behavior) है। कंपाइलर कोई एरर नहीं देगा, प्रोग्राम चल सकता है, या आपकी हार्ड ड्राइव मिटा सकता है। मज़ाक है, लेकिन सच्चाई के करीब है।

UB के उदाहरण:

\n
• एरे की सीमा से बाहर जाना: int arr[5]; arr[10] = 42;
\n
• नल पॉइंटर को डीरेफरेंस करना: int* p = nullptr; *p = 5;
• इनिशियलाइज़ेशन से पहले वेरिएबल का उपयोग करना।

int x; // इनिशियलाइज़ नहीं किया गया
std::cout << x; // UB: कचरा, 0 प्रिंट कर सकता है या क्रैश कर सकता है

सुझाव: हमेशा वेरिएबल्स को इनिशियलाइज़ करें। रॉ एरे के बजाय std::array या std::vector का उपयोग करें - वे (डीबग मोड में) सीमाओं की जाँच करते हैं।

4. पॉइंटर और रेफरेंस के बीच भ्रम

शुरुआती अक्सर int* p और int& ref के बीच अंतर नहीं समझते। गलती: रेफरेंस को रीअसाइन करने की कोशिश करना, या पॉइंटर को डीरेफरेंस करना भूल जाना।

सामान्य गलती:

void change(int* p) {
    p = new int(10); // पॉइंटर की लोकल कॉपी बदल रहे हैं, ओरिजिनल नहीं बदला
}

int main() {
    int* ptr = nullptr;
    change(ptr);
    std::cout << *ptr; // UB: ptr अभी भी nullptr है
}

सही तरीका: पॉइंटर को रेफरेंस से पास करें (int*& p) या यदि एड्रेस बदलने की आवश्यकता नहीं है तो रेफरेंस का उपयोग करें।