const int*, int * const, const int * const: पूरी समझ आसान भाषा में

परिचय: यह टॉपिक अनुभवी C++ डेवलपर्स को भी क्यों परेशान करता है?

अगर आपने कभी C++ का कोई कोड खोला है और उसमें const int * const data जैसा कुछ देखा है, तो शायद आपने एडिटर बंद करके चाय पीने का मन किया होगा। const का यह अजीब सिंटैक्स, जो तारे (asterisk) के दोनों तरफ बिखरा होता है, एक बड़ी समस्या है। Stack Overflow पर «What is the difference between const int*, const int * const, and int * const?» सवाल ने लाखों व्यूज जुटाए हैं। और यह कोई संयोग नहीं है।

इन कंस्ट्रक्शन को समझना सिर्फ पांडित्य का मामला नहीं है। यह सुरक्षित, स्व-दस्तावेजीकरण कोड लिखने और, सबसे महत्वपूर्ण, इंटरव्यू पास करने की कुंजी है। आज हम एक सरल नियम का उपयोग करके इस भ्रम को हमेशा के लिए दूर करेंगे।

तीन मुख्य प्रकार: हम क्या तुलना करेंगे?

C++ में पॉइंटर्स और कॉन्स्टेंटनेस चार तरीकों से जुड़ सकते हैं (तीन सबसे लोकप्रिय हैं)। आइए उन्हें देखें:

\n
• विकल्प 1: const int* ptr (या int const* ptr — ये एक ही हैं)।
\n
• विकल्प 2: int * const ptr।
\n
• विकल्प 3: const int * const ptr (पहले दो का संयोजन)।
\n

मुख्य विचार: const हमेशा उस चीज़ को संदर्भित करता है जो इसके बाईं ओर है। अगर बाईं ओर कुछ नहीं है, तो दाईं ओर की चीज़ को। यह सरल लगता है, लेकिन व्यवहार में यह नियम बहुत काम आता है।

विकल्प 1: const int* ptr (कॉन्स्टेंट इंटीजर पर पॉइंटर)

दाएं से बाएं पढ़ें: «ptr एक पॉइंटर है जो एक कॉन्स्टेंट इंटीजर की ओर इशारा करता है»।

व्यवहार में इसका क्या मतलब है?

\n
• आप नहीं कर सकते उस वेरिएबल का मान बदल सकते हैं जिस पर ptr इशारा कर रहा है, इस पॉइंटर के माध्यम से।
\n
• आप कर सकते हैं पॉइंटर को ही बदल सकते हैं (इसे किसी दूसरे वेरिएबल पर इशारा करने के लिए मजबूर कर सकते हैं)।
\n

#include <iostream>\n\nint main() {\n    int a = 10;\n    int b = 20;\n\n    const int* ptr = &a;  // ptr — const int पर पॉइंटर\n\n    // *ptr = 15; // कंपाइलेशन एरर! const int* के जरिए मान नहीं बदल सकते\n    std::cout << "*ptr = " << *ptr << std::endl; // 10 प्रिंट होगा\n\n    ptr = &b; // ठीक है! पॉइंटर को बदल रहे हैं\n    std::cout << "*ptr = " << *ptr << std::endl; // 20 प्रिंट होगा\n\n    return 0;\n}

इस प्रकार का उपयोग अक्सर फंक्शन में डेटा भेजने के लिए किया जाता है, जब आप गारंटी देना चाहते हैं कि फंक्शन मूल डेटा को खराब नहीं करेगा। उदाहरण के लिए, void print(const int* data) — यह "केवल पढ़ने" का वादा है।

विकल्प 2: int * const ptr (इंटीजर पर कॉन्स्टेंट पॉइंटर)

दाएं से बाएं पढ़ें: «ptr एक कॉन्स्टेंट पॉइंटर है जो एक इंटीजर की ओर इशारा करता है»।

यहाँ सब कुछ उल्टा है:

\n
• आप कर सकते हैं उस वेरिएबल का मान बदल सकते हैं जिस पर ptr इशारा कर रहा है।
\n
• आप नहीं कर सकते पॉइंटर को ही बदल सकते हैं (इसे हमेशा एक ही मेमोरी लोकेशन पर इशारा करना चाहिए)।
\n

#include <iostream>\n\nint main() {\n    int a = 10;\n    int b = 20;\n\n    int * const ptr = &a; // ptr — int पर कॉन्स्टेंट पॉइंटर\n\n    *ptr = 15; // ठीक है! पॉइंटर के जरिए मान बदल रहे हैं\n    std::cout << "*ptr = " << *ptr << std::endl; // 15 प्रिंट होगा\n\n    // ptr = &b; // कंपाइलेशन एरर! पॉइंटर को नहीं बदल सकते\n\n    return 0;\n}

समझें कि int * const एक "बंधा हुआ" पॉइंटर है। इसका उपयोग अक्सर हार्डवेयर रजिस्टरों के साथ काम करने या उन मामलों में किया जाता है जहाँ बफर का पॉइंटर कहीं और "भाग" नहीं जाना चाहिए।

विकल्प 3: const int * const ptr (कॉन्स्टेंट इंटीजर पर कॉन्स्टेंट पॉइंटर)

दाएं से बाएं पढ़ें: «ptr एक कॉन्स्टेंट पॉइंटर है जो एक कॉन्स्टेंट इंटीजर की ओर इशारा करता है»।