Reference and Pointer (Contd.) ( Lecture 11)-GtsBZ5e1-cE

C++ में प्रोग्रामिंग(programming) में मॉड्यूल(module) 7 में आपका स्वागत है।
 हमने संदर्भ(reference) की मूल अवधारणा पर चर्चा की है और इसका उपयोग करके हमने संदर्भ(reference) द्वारा कॉल की धारणा पेश की है।
 और, हमने दिखाया है कि संदर्भ(reference) तंत्र द्वारा कॉल का उपयोग करके सी ++ में स्वैपिंग जैसे कुछ कार्यों को बेहतर तरीके से कैसे लिखा जा सकता है।
 हमने यह भी चर्चा की है कि एक संदर्भ(reference) पैरामीटर(parameter) एक फ़ंक्शन(function) के लिए एक सामान्य इनपुट(input) / आउटपुट(output) पैरामीटर(parameter) हो सकता है।
 इसलिए, यदि मैं नहीं चाहता कि फ़ंक्शन(function) औपचारिक पैरामीटर(parameter) को बदले और वास्तविक पैरामीटर(parameter) में परिणामी परिवर्तन करे, तो हमारे पास एक संदर्भ(reference) पैरामीटर(parameter) को परिभाषित करने का एक विकल्प है एक const पैरामीटर(parameter), जिसके द्वारा इसे केवल वास्तविक पैरामीटर(parameter) द्वारा प्रारंभ किया जा सकता है ।
 लेकिन, इसके लिए किए गए किसी भी परिवर्तन को संकलक द्वारा अनुमति नहीं दी जाएगी।
 हम अब अगले जारी रखेंगे और फ़ंक्शन(function) तंत्र के दूसरे पक्ष के बारे में बात करेंगे।
 C में, हम किसी फ़ंक्शन(function) से मान वापस पाने के लिए तंत्र का उपयोग करते हैं; को वैल्यू मैकेनिज़्म कहा जाता है।
 यही है, चूंकि मापदंडों को वास्तविक से औपचारिक रूप में कॉपी किया जाता है, रिटर्न वैल्यू भी रिटर्न वैल्यू एक्सप्रेशन(expression) से कॉपी की जाती है, जिसे हम रिटर्न स्टेटमेंट में वापस लिखते हैं जहां हम उस फ़ंक्शन(function) मान को असाइन कर रहे हैं।
 तो, सी ++ में इसके विपरीत संदर्भ(reference) द्वारा एक मूल्य वापस करना संभव है।
 आइए हम देखें कि हम क्या कह रहे हैं।
 तो, पहले हम दोनों पक्षों पर ध्यान केंद्रित करते हैं।
 बाईं ओर, हमारे पास मूल्य से वापसी है; दाईं ओर, हम संदर्भ(reference) द्वारा लौटे हैं।
 इसलिए, बाईं ओर हमारे पास एक फ़ंक्शन(function) है जो C ++ में एक विशिष्ट सी रिटर्न फॉर्म है।
 यह केवल संदर्भ(reference) द्वारा कॉल का उपयोग कर रहा है।
 और दाईं ओर, कृपया ध्यान दें कि वापसी प्रकार के बाद हमारे पास संदर्भ(reference) प्रतीक है।
 इसलिए, अगर यह कहता है कि हम रिटर्न एक्सप्रेशन(expression) का संदर्भ(reference) दे रहे हैं।
 और फिर, उपयोग समान है।
 यहां, हम इस फ़ंक्शन(function) को लागू करते हैं; यहाँ हम फिर से इस समारोह का आह्वान करते हैं।
 और फ़ंक्शन(function) का परिणाम रखने के लिए, और यह मुख्य रूप से आपके लिए प्रभाव को दिखाने के उद्देश्य से है।
 मैंने एक और संदर्भ(reference) चर(variable) b का उपयोग किया है।
 इसलिए, b उस मान का संदर्भ(reference) रखेगा जो लौटाया गया है।
 यदि आप इस भाग पर मौजूद वैल्यू पार्ट के रिटर्न को देखते हैं, तो आपको यह समझना होगा कि यह संदर्भ(reference) बी एक स्थिर होना चाहिए।
 यह एक स्थिर क्यों होना चाहिए? क्योंकि यदि आप संदर्भ(reference) परिभाषा के नुकसान को याद करते हैं, तो हमने दिखाया था कि अगर मेरे पास एक अभिव्यक्ति j + k है, तो मैं उसका संदर्भ(reference) नहीं बना सकता क्योंकि j + k की गणना एक अस्थायी में की जाती है।
 अब, यहाँ मेरे पास दाईं ओर क्या है? मेरे पास एक समारोह आह्वान है।
 एक समारोह आह्वान क्या है? यह एक अभिव्यक्ति है।
 इसलिए, मैं उस पर कोई अंतर नहीं लिख सकता।
 मुझे इसके लिए एक निरंतर संदर्भ(reference) लिखना होगा, जो कि अस्थायी स्थान है जिसे इस संदर्भ(reference) के माध्यम से संरक्षित किया जाएगा।
 इस पर, निरंतर लिखना केवल एकरूपता के लिए है।
 यह वास्तव में आवश्यक नहीं है।
 तुम समझ जाओगे कि एक बार तुम तंत्र को समझ लो।
 आइए अब आउटपुट(output) पर नजर डालें।
 तो, पहला आउटपुट(output) जो कॉट आएगा जो यहाँ है, जो एक प्रिंट करता है, और उसका पता।
 अगला फ़ंक्शन(function) के भीतर है।
 समारोह को बुलाया गया है।
 इस प्रिंट के बाद, फ़ंक्शन(function) को यहां बुलाया गया है।
 तो, अगला यह कॉउट है, जो यह आउटपुट(output) है जहां आप एक्स प्रिंट करते हैं।
 यह संदर्भ(reference) द्वारा एक कॉल है।
 तो जैसा कि अपेक्षित था, और x का एक ही पता(address) है।
 अंत में, आप इस तीसरे आउटपुट(output) को देखते हैं जो मुख्य से आएगा, फ़ंक्शन(function) के वापस आने के बाद।
 और, एक फ़ंक्शन(function) क्या करता है? फ़ंक्शन(function) केवल एक मान लौटाता है जिसे आपने इसे पारित किया था।
 तो, यह उसी मूल्य को वापस करने की उम्मीद है।
 तो, b समान मान लौटाता है।
 लेकिन, यदि आप यहाँ b का पता(address) प्रिंट करते हैं, तो यह x के पते या पते से अलग है।
 और, यह अपेक्षित है; क्योंकि यह मूल्य से लौट रहा है।
 तो, जो यह लौटा रहा है वह x की एक प्रति है; जो एक अस्थायी में है, और मैंने माना है कि अस्थायी बी का एक हिस्सा है; बी में एक संदर्भ(reference) के रूप में।
 संदर्भ(reference) पक्ष पर समान के बारे में सोचें।
 यहां, हम कॉल बाय बाय देख रहे हैं, संदर्भ(reference) द्वारा लौटें।
 पहला आउटपुट(output) यहाँ से आता है जो एक, और उसका पता(address) है।
 दूसरा उस फ़ंक्शन(function) से है जो x और उसका पता(address) है।
 संदर्भ(reference) से कॉल करें; उन्हें समान होना चाहिए।
 वे वास्तव में समान हैं।
 तीसरा आउटपुट(output) फंक्शन वापस आने के बाद यहां से आता है।
 आप देखते हैं कि यह केवल b ही नहीं है, b का यह पता(address) भी समान है; क्योंकि जो वास्तव में लौटाया गया है, जो लौटाया गया है, वह x का मूल्य नहीं है।
 लेकिन, जो लौटाया गया है वह एक संदर्भ(reference) है जो x का पता(address) है; एक्स का संदर्भ(reference), जो एक्स का एक उपनाम(alias) है।
 तो, बी अब एक्स क्या था का एक उपनाम(alias) बन जाता है।
 और, एक्स क्या था? x एक का उपनाम(alias) था।
 तो, बी इस प्रक्रिया में एक का एक अन्य बन गया है।
 तो, यह मूल्य के अनुसार वापसी और संदर्भ(reference) द्वारा वापसी के बीच का अंतर है।
 फिर, यदि आप संदर्भ(reference) से लौटते हैं, तो यह कुछ दिलचस्प और मुश्किल मुद्दों को दिखाएगा।
 लेकिन अगर आप संदर्भ(reference) से लौटते हैं, तो फिर, हम बड़ी संरचनाओं की नकल से बच सकते हैं, अगर हम वापस लौटना चाहते हैं।
 इसलिए, कई स्थानों पर आप संदर्भ(reference) द्वारा वापस लौटना चाह सकते हैं।
 अब जैसा कि मैंने कहा, संदर्भ(reference) के अनुसार वापसी कई बार मुश्किल हो सकती है।
 यहाँ देखो।
 एक फ़ंक्शन(function) है जो संदर्भ(reference) द्वारा एक पैरामीटर(parameter) लेता है और उसी पैरामीटर(parameter) को संदर्भ(reference) द्वारा लौटाता है।
 और, इस रेखा को देखें और पहले हमें आपकी आंखों पर विश्वास करना होगा कि आप जो देख रहे हैं वह सही कार्यक्रम है।
 आपने कभी किसी असाइनमेंट के बाईं ओर एक फ़ंक्शन(function) इनवोकेशन नहीं देखा है।
 फ़ंक्शन(function) आमंत्रण हमेशा दाईं ओर होता है।
 तो, यहाँ यह मान्य है; क्योंकि समारोह क्या लौट रहा है? फ़ंक्शन(function) वास्तव में एक उपनाम(alias) लौटा रहा है।
 यह वास्तव में एक पता(address) दे रहा है; यह वास्तव में एक चर(variable) लौट रहा है।
 इसलिए, अगर मैं कहता हूं कि मैं इसे असाइनमेंट 3 बना रहा हूं, तो मैं वास्तव में उस उपनाम(alias) को असाइनमेंट बना रहा हूं।
 तो, आइए देखें कि इसका क्या मतलब है।
 आइए हम आउटपुट(output) को देखें।
 हमारे यहाँ आउटपुट(output) हैं।
 तो, यह cout है, फ़ंक्शन(function) को इस बिंदु पर बुलाया गया था, x 10 है, जो कि, a है।
 10. तो, यह उसी x को लौटाता है।
 तो, b 10. बन गया है।
 इसलिए, जब मैं इस आउटपुट(output) को देखता हूं, तो यह 10 है, b 10 है।
 कोई आश्चर्य की बात नहीं है।
 मैं इसे एक बार फिर यहां बुलाता हूं।
 और, रिटर्न संदर्भ(reference) के लिए 3 असाइन करें।
 तो, इसका क्या मतलब होगा? अगर मैं इसे ए के साथ बुला रहा हूं, तो ए और एक्स उर्फ बन जाते हैं।
 x एक का उपनाम(alias) है।
 मैं संदर्भ(reference) देकर लौट रहा हूं।
 तो, मैं जो लौटा वह एक्स का एक उपनाम(alias) है, जिसे ए का उपनाम(alias) होना चाहिए।
 इसलिए, मुझे यहां वापसी के रूप में जो मिला है, वह वास्तव में ए का उपनाम(alias) है।
 तो, आप इसे हमेशा एक असाइनमेंट 3 बना सकते हैं।
 वह असाइनमेंट कहां होगा? यह एक का उपनाम(alias) है।
 तो, असाइनमेंट एक में होगा।
 तो, a से बाहर की जाँच करें।
 a बन गया है 3. इसलिए, यह संभव है यदि आप संदर्भ(reference) द्वारा वापसी करते हैं।
 अब, हम बाद में जैसे ही हम आगे बढ़ेंगे, बाद की सुविधाओं के लिए, हम दिखाएंगे कि इस तरह की मुश्किल चीज़ और छोटी सी भ्रमित करने वाली चीज़ का उपयोग कार्यक्रम में कुछ स्थानों पर लाभ के लिए कैसे किया जा सकता है।
 मैं यह सलाह नहीं दे रहा हूं कि आप इस तरह का कोड बहुत बार लिखें।
 लेकिन, ऐसी जगहें हैं जहां इसका इस्तेमाल अच्छे तरीके से किया जा सकता है।
 और, यह सही कॉलम पर प्रयोग करते हुए, जिसे आपने अब तक नहीं देखा है, मैं बताता हूं कि यदि आप कुशल नहीं हैं, तो आप ऐसा करने की कोशिश में अपने पैर में गोली मार सकते हैं।
 इस कोड को देखें, जो पहले के कोड के समान है।
 एकमात्र अंतर यह है कि यह अब पैरामीटर(parameter) x लेता है, जो स्वाभाविक रूप से एक का उपनाम(alias) है, क्योंकि यह संदर्भ(reference) द्वारा कॉल किया गया है और इसमें एक स्थानीय चर(variable) टी है यह x के साथ t को इनिशियलाइज़ करता है और फिर t को बढ़ाता है।
 और फिर, यहाँ देखें, पहले यह एक्स लौट रहा था।
 अब, यह t देता है जो संदर्भ(reference) के रूप में यह स्थानीय चर(variable) है।
 और, आपने यहाँ एक ही काम किया।
 पहली दो पंक्तियाँ समान हैं।
 वे एक ही आउटपुट(output) का उत्पादन करते हैं।
 तो, देखने के लिए कुछ भी नहीं है।
 इस लाइन को देखो।
 आपने यहां ऐसा किया है।
 इसलिए, यदि आप ऐसा करते हैं और यह उम्मीद करने की कोशिश करते हैं कि, कुछ बदलाव होगा, या ऐसा कुछ होगा।
 आप हैरान होंगे कि कुछ भी नहीं होगा; क्योंकि आपने क्या किया है? आपने वास्तव में एक स्थानीय चर(variable) लौटाया है।
 तो, यहाँ जो मिलता है, वह स्थानीय चर(variable) t का संदर्भ(reference) है।
 और यह बहुत जोखिम भरा है; क्योंकि एक बार जब आपने संदर्भ(reference) वापस कर लिया है, तो फ़ंक्शन(function) कॉल समाप्त हो गया है।
 तो, स्थानीय चर(variable) गायब हो गया है, लेकिन आपका संदर्भ(reference) अभी भी जीवित है।
 तो, आपका संदर्भ(reference) कहता है कि मेरे पास परिवर्तनशील है।
 फ़ंक्शन(function) कॉल समाप्त हो गया है।
 तो, यह वास्तव में मौजूद नहीं है।
 यह चर(variable) टी अब मौजूद नहीं है, यह मृत है।
 लेकिन, आप इसका एक संदर्भ(reference) रखते हैं।
 तो, इस तरह के कार्यक्रम के परिणाम बहुत अप्रत्याशित हो सकते हैं।
 तो, लब्बोलुआब यह है कि यदि आप संदर्भ(reference) द्वारा रिटर्न का उपयोग कर रहे हैं, तो स्थानीय वेरिएबल को कभी वापस न करें।
 यदि आप संदर्भ(reference) से लौट रहे हैं, तो हमेशा उपलब्ध होने वाले चर(variable) को लौटाएं, जो फ़ंक्शन(function) कॉल समाप्त होने के बाद तार्किक रूप से लाइव होना चाहिए।
 इसलिए, वे चर(variable) वैश्विक हो सकते हैं, वे चर(variable) जो हम देखेंगे कि वे स्थिर सदस्य हो सकते हैं, वे वास्तविक पैरामीटर(parameter) हो सकते हैं जो आपको औपचारिक पैरामीटर(parameter) में उर्फ के रूप में मिले, वे गतिशील रूप से आवंटित मूल्य और इतने पर हो सकते हैं।
 लेकिन, स्वचालित स्थानीय चर(variable) जो किसी फ़ंक्शन(function) के पास नहीं हैं, क्योंकि यह आपको वास्तविक कठिनाई में डाल सकता है और ये ऐसे बग हैं जिनका पता(address) लगाना बहुत मुश्किल है; क्योंकि आपको कोड में कुछ भी दिखाई नहीं देगा।
 कोड पर, यह सब कुछ साफ और सरल दिखता है।
 लेकिन, फिर भी आपके परिणाम अप्रत्याशित हो जाएंगे।
 अंत में, जैसा कि हमने इस मॉड्यूल(module) के माध्यम से देखा है, संदर्भ(reference) एक चर(variable) के उपनाम(alias) के बारे में बात कर रहा है यह एक तंत्र है जो आपको वास्तव में चर(variable) का नाम लिए बिना एक चर(variable) के मूल्य को बदलने की अनुमति देता है ।
 तो, इस तरह से इसे संकेतकर्ताओं के साथ बहुत समानता और अंतर मिला है।
 इसलिए, मैं इन दो कॉलमों में इस अंतर को संक्षेप में बताऊंगा।
 तो, संकेत और संदर्भ(reference) के बीच, दोनों पते को संदर्भित करते हैं।
 संकेत पते को संदर्भित करते हैं; संदर्भ(reference) एक पते को भी संदर्भित करता है।
 तो, वे उस हद तक समान हैं, लेकिन वे कई मायनों में भिन्न हैं।
 उदाहरण के लिए, अगले बिंदु को देखें।
 संकेत NULL को इंगित कर सकते हैं; मैं एक सूचक(pointer) को अशक्त करने के लिए असाइन कर सकता हूं।
 इसका क्या मतलब है? शब्दार्थ, इसका मतलब है कि मैं कहीं भी इंगित नहीं कर रहा हूं।
 इसका कोई इंगित डेटा(data) नहीं है जिसे मैं ले जाऊं।
 लेकिन, संदर्भ(reference) पूर्ण नहीं हो सकता; क्योंकि यह एक उपनाम(alias) है।
 यह सिर्फ एक उपनाम(alias) है।
 तो, यह प्रभाव के लिए एक चर(variable) है।
 तो, यह एक बुनियादी अंतर है।
 चूंकि पॉइंटर(pointer) अलग-अलग अन्य डेटा(data) को इंगित करता है, जब तक कि कोई पॉइंटर(pointer) स्थिर नहीं होता है, मैं वास्तव में उस डेटा(data) को बदल सकता हूं जो वह इंगित कर रहा है।
 तो, उदाहरण से स्पष्ट है कि आप ऐसा कर सकते हैं।
 यदि पी शुरू में एक को इंगित कर रहा था, तो यह कुछ बिंदु बयानों पर, यह बी को इंगित कर सकता है।
 लेकिन, एक संदर्भ(reference); एक संदर्भ(reference) के लिए, आप जो उल्लेख कर रहे हैं वह परिभाषा द्वारा तय किया गया है; क्योंकि यह एक चर(variable) के लिए एक वैकल्पिक नाम है।
 इसलिए, निश्चित रूप से मैं उस संदर्भ(reference) को बदल नहीं सकता और नाम को अलग बना सकता हूं।
 उदाहरण के लिए, यदि हम अभी इस पंक्ति में देखें, यदि आप ऐसा करने का प्रयास कर रहे हैं, तो आप यह हासिल नहीं कर पाएंगे कि यदि आप इसे b & c c के रूप में लिखते हैं, तो यह सोचकर कि आप b का संदर्भ(reference) बदल देंगे, ए से सी।
 आप ऐसा नहीं कर पाएंगे क्योंकि एक पल आप लिखते हैं और बी।
 चूंकि, यह ए के लिए एक उपनाम(alias) है, और बी को ए और ए के रूप में समझा जाएगा, क्योंकि यह एक उपनाम(alias) है।
 इसलिए, जो कुछ भी आप बी के रूप में लिखते हैं, उस पर क्या लागू होना चाहिए, क्योंकि यह ए का उपनाम(alias) है।
 और फिर, &a का एक पता(address) है; और & पता(address) ऑपरेटर(operator) है।
 तो, आप जो कह रहे हैं; आप सी के पते पर असाइन करने की कोशिश कर रहे हैं, जो कि व्यर्थ बात है।
 तो, आप सभी संभावनाओं में प्रयास कर सकते हैं।
 उदाहरण के लिए, यदि आप ठीक कहने का प्रयास करते हैं, तो, मैं c को b लगाकर संदर्भ(reference) बदलना चाहूंगा, लेकिन तब b एक है।
 इसलिए, यदि आप c से b असाइन करने का प्रयास करते हैं, तो आप मूल रूप से c को असाइन कर रहे हैं।
 ऐसा कोई तरीका नहीं है कि भाषा आपको किसी भी तंत्र, किसी भी ऑपरेटर(operator) को संदर्भ(reference) के साथ कुछ भी करने के लिए नहीं देती है।
 आप केवल उल्लेख कर सकते हैं।
 और, जो कुछ भी आप वास्तव में व्याख्या करते हैं, वह संदर्भित डेटा(data) के संदर्भ(reference) में है।
 तो, यह एक बुनियादी अंतर है।
 संकेतकर्ताओं के लिए, क्योंकि यह संभव है कि मैं कहीं इशारा नहीं कर रहा हूं।
 एक पॉइंटर(pointer) का उपयोग करने से पहले, हमें नल की जांच करने की आवश्यकता है।
 संदर्भ(reference) की आवश्यकता नहीं है क्योंकि यह है, यदि यह मौजूद है, तो यह किसी चीज का उपनाम(alias) है या इसका अस्तित्व नहीं है।
 तो, यह कोड को लिखने में बहुत आसान बनाता है।
 आपको इसके बारे में परेशान करने की ज़रूरत नहीं है और निश्चित रूप से यह उस अर्थ में तेज़ बनाता है क्योंकि उन चेकों की आवश्यकता नहीं है।
 अंत में, यदि आप वास्तव में देखते हैं यदि संकेत और संदर्भ(reference) दोनों पते हैं, और वास्तव में क्या अंतर है? अंतर सशक्तिकरण में नहीं है, संदर्भ(reference) के लिए आपको जो मिलता है, उसके संदर्भ(reference) में नहीं।
 अंतर यह है कि संदर्भ(reference) के लिए आपको क्या नहीं मिलता है।
 यदि आपके पास एक पॉइंटर(pointer) वैरिएबल है, तो आपको कई ऑपरेटर(operator) दिए गए हैं जो आप उस वैरिएबल के साथ काम कर सकते हैं।
 आप वास्तव में उस पते का उपयोग मूल्य के रूप में कर सकते हैं और विभिन्न चीजों को कर सकते हैं।
 आप इसमें एक पूर्णांक जोड़ सकते हैं और एक पॉइंटर(pointer) को आगे बढ़ा सकते हैं।
 आप दो पॉइंटर(pointer) मान ले सकते हैं और एक अंतर बना सकते हैं और देख सकते हैं कि एक सरणी में इन दो बिंदुओं के बीच कितने तत्व मौजूद हैं।
 तो, ये सभी ऑपरेटर(operator) आपको दिए गए हैं, जिसके द्वारा आप पॉइंटर(pointer) को जिस भी तरीके से चाहें बदल सकते हैं; जो सूचक(pointer) को इतना शक्तिशाली बनाता है।
 संदर्भ(reference) में, पता(address) भी संग्रहीत है।
 लेकिन, ऐसा कोई तरीका नहीं है जिससे आप उस पते को पकड़ सकें।
 आप उस पते को पकड़ नहीं सकते।
 कोई भी ऑपरेशन नहीं है जो संदर्भ(reference) पर दिया गया है।
 कोई भी ऑपरेशन जो आप करने की कोशिश करते हैं, वास्तव में संदर्भित ऑब्जेक्ट या रेफ़रेंट पर काम करने के लिए उबलते हैं।
 तो, यह बुनियादी अंतर है।
 और, जिस तरह से सी ++ को डिज़ाइन किया गया है, दोनों बिंदुओं और संदर्भों का अपना अलग स्थान है।
 संकेत और संदर्भ(reference) के साथ दूर करना संभव नहीं है, वास्तव में एक मूल्य है, लेकिन ऐसी भाषाएं हैं जहां आपके पास ये दोनों तंत्र नहीं हैं।
 इसलिए, यह समझना अच्छा है।
 विशेष रूप से, यदि आप कुछ जावा जानते हैं तो आपको पता(address) होगा कि जावा में एक संदर्भ(reference) है, एक सूचक(pointer) नहीं है।
 और, मैं सिर्फ इस बिंदु को उठा रहा हूं क्योंकि मैं चाहता हूं कि आप ध्यान दें कि जावा में संदर्भ(reference) सी ++ में संदर्भ(reference) की तरह नहीं है।
 इसलिए, यदि आपने सोचा है कि मुझे संदर्भ(reference) की अवधारणा में अधिक स्पष्टीकरण देने दें और पसंदीदा जावा पुस्तक पढ़ें, तो आप केवल अधिक भ्रमित हो जाएंगे।
 तो, C ++ में जावा के संदर्भ(reference) का कोई वास्तविक समानांतर नहीं है, लेकिन यह ज्यादातर निरंतर सूचक(pointer) के समान है।
 आपके पास जावा में एक संदर्भ(reference) है जो वास्तव में एक सूचक(pointer) है, लेकिन यह एक निरंतर सूचक(pointer) है जिसे आप इसे बदल नहीं सकते हैं।
 लेकिन, यह न तो पूरी तरह से एक पॉइंटर(pointer) है और न ही सी ++ में पूरी तरह से एक संदर्भ(reference) है।
 और, भाषाएं हैं; जैसे c का संदर्भ(reference) नहीं है।
 ऐसी भाषाएं हैं जिनमें पॉइंटर्स वगैरह नहीं हैं।
 C ++ में हम दोनों हैं।
 इसलिए, हमारे पास एक दिए गए संदर्भ(reference) में निर्णय लेने की एक बड़ी जिम्मेदारी है, चाहे हमें सूचक(pointer) का उपयोग करने की आवश्यकता हो या हमें एक संदर्भ(reference) का उपयोग करने की आवश्यकता हो।
 और जैसा कि हम साथ चलते हैं, विभिन्न विशेषताएं और विभिन्न प्रोग्रामिंग(programming) उदाहरण इस बात पर प्रकाश डालते रहेंगे कि विकल्प आपके लिए कुशल C ++ प्रोग्रामर बनने के लिए विवेकपूर्ण और सही है।
 इसलिए, इस मॉड्यूल(module) 7 में, हमने C ++ में संदर्भ(reference) की अवधारणा को पेश किया है और हमने मूल्य द्वारा कॉल और संदर्भ(reference) द्वारा कॉल के बीच के अंतर का अध्ययन किया है।
 हमने संदर्भ(reference) द्वारा वापसी की अवधारणा भी पेश की है और दो तंत्रों के बीच के अंतर का अध्ययन किया है।
 हमने कुछ दिलचस्प नुकसान, चालें, मुश्किल हालात दिखाए हैं जो इससे उत्पन्न हो सकते हैं और हमने संदर्भ(reference) और संकेत के बीच अंतर के बारे में चर्चा की है।