C++ में पॉइंटर्स और रेफरेंसेस: अंतर और 2025 के सर्वोत्तम अभ्यास

C++ में पॉइंटर्स और रेफरेंसेस: 2025 में क्या अंतर है और क्या चुनें?

कल्पना करें कि आप एक कमरे के दरवाजे के सामने खड़े हैं। आपके पास अंदर जाने के दो तरीके हैं: आप एक चाबी (पॉइंटर) ले सकते हैं या बस अपने हाथ से दरवाजा खोल सकते हैं (रेफरेंस)। दोनों तरीके आपको अंदर ले जाएंगे, लेकिन वे अलग-अलग तरीके से काम करते हैं। C++ में पॉइंटर्स और रेफरेंसेस के साथ भी लगभग ऐसा ही है।

यह प्रश्न Stack Overflow पर सबसे लोकप्रिय प्रश्नों में से एक है (2 मिलियन से अधिक बार देखा गया!)। और यह उचित भी है: pointer और reference के बीच भ्रम शुरुआती लोगों के लिए एक क्लासिक जाल है। 2025 में, C++23 और नए मानकों के आने के साथ, इन अंतरों को समझना और भी महत्वपूर्ण हो गया है। आइए इसे हमेशा के लिए समझ लें।

पॉइंटर और रेफरेंस के बीच मुख्य अंतर

आइए मूल बातों से शुरू करें। यहाँ मुख्य अंतर दिए गए हैं जो प्रत्येक C++ डेवलपर को पता होने चाहिए:

\n
• रेफरेंस (reference) — एक मौजूदा वेरिएबल का उपनाम (alias) है। इसे बनाते समय आरंभिक (initialize) किया जाना चाहिए और इसे किसी अन्य ऑब्जेक्ट पर पुनर्निर्देशित नहीं किया जा सकता है।
\n
• पॉइंटर (pointer) — एक वेरिएबल है जो किसी अन्य वेरिएबल का पता (address) संग्रहीत करता है। इसे पुनर्निर्देशित किया जा सकता है, बदला जा सकता है, और यह nullptr हो सकता है।
\n

सरल लगता है? आइए इसे उदाहरणों के साथ समझें।

उदाहरण 1: आरंभीकरण (Initialization)

#include <iostream>\n\nint main() {\n    int value = 42;\n    \n    // रेफरेंस — तुरंत आरंभिक किया जाना चाहिए\n    int& ref = value;  // ठीक है\n    // int& ref2;       // संकलन त्रुटि!\n    \n    // पॉइंटर — आरंभिक नहीं भी हो सकता है (लेकिन यह खतरनाक है)\n    int* ptr = &value;  // ठीक है\n    int* ptr2 = nullptr; // ठीक है, सुरक्षित\n    // int* ptr3;        // अपरिभाषित व्यवहार!\n    \n    std::cout << "ref = " << ref << ", *ptr = " << *ptr << std::endl;\n    return 0;\n}

उदाहरण 2: पुनर्निर्देशन (Reassignment)

#include <iostream>\n\nint main() {\n    int a = 10;\n    int b = 20;\n    \n    // रेफरेंस: हमेशा के लिए a से बंधा हुआ\n    int& ref = a;\n    ref = b;  // रेफरेंस को पुनर्निर्देशित नहीं करता! बस a को b का मान निर्दिष्ट करता है (a = 20)\n    \n    // पॉइंटर: पुनर्निर्देशित किया जा सकता है\n    int* ptr = &a;\n    ptr = &b;  // अब ptr, b की ओर इशारा करता है\n    \n    std::cout << "a = " << a << ", *ptr = " << *ptr << std::endl;\n    // आउटपुट: a = 20, *ptr = 20\n    return 0;\n}

अंतर देखा? रेफरेंस उसी कमरे का दूसरा दरवाजा है। पॉइंटर पते वाला एक नेमप्लेट है जिसे दूसरे दरवाजे पर लटकाया जा सकता है।

रेफरेंस का उपयोग कब करें?

C++ में रेफरेंसेस फंक्शन में पैरामीटर पास करने के लिए आपकी डिफ़ॉल्ट पसंद है। क्यों? क्योंकि वे अधिक सुरक्षित हैं: आप गलती से nullptr पास नहीं कर सकते या डीरेफरेंस करना भूल नहीं सकते।

2025 के सर्वोत्तम अभ्यास: रेफरेंसेस

\n
• फंक्शन पैरामीटर (कॉन्स्टेंट रेफरेंस द्वारा) — जब ऑब्जेक्ट को बदलने की आवश्यकता न हो:
\n

void printMessage(const std::string& msg) {\n    std::cout << msg << std::endl;\n    // msg एक उपनाम है, कोई कॉपी नहीं होती\n}

\n
• फंक्शन से वापसी — जब ऑब्जेक्ट के वापसी के बाद भी मौजूद रहने की गारंटी हो:
\n

class Container {\n    std::vector<int> data;\npublic:\n    // एलिमेंट का रेफरेंस लौटाता है (यह कंटेनर के अंदर रहता है)\n    int& operator[](size_t index) {\n        return data[index];\n    }\n};

\n
• ऑपरेटर ओवरलोडिंग — एक क्लासिक उदाहरण:
\n

Complex& operator+=(const Complex& other);  // *this को रेफरेंस द्वारा लौटाता है

पॉइंटर का उपयोग कब करें?

पॉइंटर्स C++ के स्विस आर्मी चाकू हैं। वे अधिक शक्तिशाली हैं, लेकिन सावधानी की आवश्यकता है। 2025 में, स्मार्ट पॉइंटर्स के कारण उनका उपयोग अधिक अनुशासित हो गया है