C++ किसी मान या पते को पॉइंटर्स के बजाय उसके संदर्भ द्वारा वापस करने की सुविधा प्रदान करता है। पॉइंटर्स के बजाय संदर्भों का उपयोग करने से C++ प्रोग्राम को पढ़ना और प्रबंधित करना आसान हो सकता है। C++ में, संदर्भ और संकेत एक दूसरे से निकटता से संबंधित हैं। प्राथमिक अंतर यह है कि यद्यपि संदर्भ केवल एक वैकल्पिक नाम है, किसी अन्य चर के लिए 'उपनाम', पॉइंटर्स का उपयोग मान जोड़ने जैसे कार्यों में किया जा सकता है। संदर्भ एक वैकल्पिक नाम या मूल मान का डुप्लिकेट है और इसे '&' प्रतीक द्वारा दर्शाया जाता है।
उदाहरण 1:
हम 'iostream' हेडर फ़ाइल आयात करते हैं और फिर 'std' नेमस्पेस का उपयोग करते हैं। हेडर फ़ाइलें C++ कोड में आयात की जाती हैं क्योंकि कई फ़ंक्शन परिभाषित होते हैं। फिर, हम फ़ंक्शन के नाम, 'returnTheValue' के साथ '&' प्रतीक रखकर एक रिटर्न संदर्भ फ़ंक्शन बनाते हैं।
यहां, 'मूल्य' संदर्भ अब डाला गया है। इसके नीचे, हम '&value' संदर्भ के साथ मूल्य और पता प्रिंट करते हैं। फिर, हम रिटर्न संदर्भ डालते हैं और 'मान' डालते हैं। अब, 'मुख्य()' को यहां लागू किया गया है, और हम '44' के मान के साथ 'एन1' को आरंभ करते हैं। इसके नीचे, 'int& n2' को 'returnTheValue(n1)' से आरंभ किया गया है। अब, हम 'n1' का मान और उसका पता प्रिंट करते हैं। फिर, हम 'cout' का उपयोग करके 'n2' के मान के साथ-साथ 'n2' के पते को भी प्रिंट करते हैं।
कोड 1:
#शामिल करें
नेमस्पेस एसटीडी का उपयोग करना;
int यहाँ & रिटर्नदवैल्यू ( int यहाँ & कीमत )
{
अदालत << 'मूल्य = ' << कीमत << अंतः
<< 'मूल्य का पता है'
<< & कीमत << एंडल;
वापस करना कीमत;
}
मुख्य प्रवेश बिंदु ( )
{
आप n1 = 44 ;
int यहाँ & n2 = returnTheValue ( एन 1 ) ;
अदालत << 'एन1 = ' << एन 1 << अंतः
<< 'n1 का पता है'
<< & एन 1 << एंडल;
अदालत << 'एन2=' << एन 2 << अंतः
<< 'n2 का पता है'
<< & एन 2 << एंडल;
वापस करना 0 ;
}
आउटपुट:
यहां, हम ध्यान दे सकते हैं कि एक संदर्भ किसी अन्य चर का केवल एक वैकल्पिक नाम है जैसा कि निम्नलिखित में दिखाया गया है। मान के पते के रूप में, 'n1' और 'n2' कभी नहीं बदलते।
उदाहरण 2:
हम 'iostream' हेडर फ़ाइल आयात करने के बाद 'std' नेमस्पेस का उपयोग करते हैं। इसके बाद, हम रिटर्न रेफरेंस फ़ंक्शन बनाने के लिए फ़ंक्शन नाम 'MyReturnValueFunc' और '&' प्रतीक का उपयोग करते हैं। 'v1' वेरिएबल का संदर्भ यहां दिया गया है। हम इसके नीचे '&v1' संदर्भ के साथ मूल्य और पता प्रिंट करते हैं। इसके बाद, हम इस स्थान पर 'रिटर्न' और 'v1' का उपयोग करके 'रिटर्न रेफरेंस' सम्मिलित करते हैं। यहां, 'मुख्य()' को कॉल किया जाता है, और 'num_1' को '19' के मान से आरंभ किया जाता है। 'int& num_2' का आरंभीकरण 'MyReturnValueFunc(num_1)' से किया जाता है।
वर्तमान में, हम 'num_1' का मान और पता प्रिंट करते हैं और, 'cout' का उपयोग करके, हम 'num_2' का मान और पता प्रिंट करते हैं। अब हम 'MyReturnValueFunc' द्वारा यहां लौटाए गए पते का उपयोग करके 'num_1' का मान बदलते हैं। यह फ़ंक्शन 'v1' का वैकल्पिक नाम लौटाता है जो कि 'num_1' का भी वैकल्पिक नाम है। इसलिए, हम इसका मान बदलते हैं और इसे '91' पर सेट करते हैं। हम 'MyReturnValueFunc(num_1)' को '91' निर्दिष्ट करते हैं जो यहां उपनाम के रूप में कार्य करता है। फिर, हम फिर से मान और 'num_1' का पता प्रिंट करते हैं।
कोड 2:
#शामिल करेंनेमस्पेस एसटीडी का उपयोग करना;
int यहाँ & MyReturnValueFunc ( int यहाँ & v1 )
{
अदालत << 'v1 का मान = ' << v1 << अंतः
<< 'v1 वेरिएबल का पता है'
<< & v1 << एंडल;
वापस करना v1;
}
मुख्य प्रवेश बिंदु ( )
{
int num_1 = 19 ;
int यहाँ & num_2 = MyReturnValueFunc ( संख्या_1 ) ;
अदालत << 'num_1 का मान = ' << संख्या_1 << अंतः
<< ' num_1 का पता है '
<< & संख्या_1 << एंडल;
अदालत << 'num_2 का मान = ' << संख्या_2 << अंतः
<< ' num_2 का पता है '
<< & संख्या_2 << एंडल;
MyReturnValueFunc ( संख्या_1 ) = 91 ;
अदालत << 'अब, num_1 का मान = ' << संख्या_1 << अंतः
<< 'नंबर_1 का पता है'
<< & संख्या_1 << एंडल;
वापस करना 0 ;
}
आउटपुट:
जैसा कि निम्नलिखित में दिखाया गया है, हम देख सकते हैं कि एक संदर्भ किसी अन्य चर के लिए एक वैकल्पिक नाम मात्र है क्योंकि 'v1', 'num_1' और 'num_2' मानों का पता स्थिर रहता है:
उदाहरण 3:
'iostream' हेडर फ़ाइल आयात की जाती है और 'std' नेमस्पेस का उपयोग किया जाता है। चूंकि हेडर फ़ाइलों में कई फ़ंक्शन निर्दिष्ट हैं, हम उन्हें C++ कोड में आयात करते हैं। यहां, हम एक 'ReturnRefFun()' फ़ंक्शन बनाते हैं जिसमें हम 'int& my_ref' डालते हैं जो संदर्भ लौटाता है। 'int& ReturnRefFun' को यहां संदर्भ फ़ंक्शन के रूप में घोषित किया गया है। इसके बाद, हम 'my_ref' वेरिएबल का मान बढ़ाते हैं। इसके नीचे, हम 'रिटर्न' डालते हैं जो 'my_ref' का संदर्भ देता है।
इसके बाद, 'मुख्य()' विधि यहां लागू की गई है। फिर, हम 'first_value' वेरिएबल को '21' से प्रारंभ करते हैं। इसके नीचे, हम 'ReturnRefFun' फ़ंक्शन में 'first_value' रखकर संदर्भ की प्रति लौटाते हैं और इसे 'copied_value' वेरिएबल में सहेजते हैं। फिर, हम 'cout' का उपयोग करके 'first_value' और 'copied_value' दोनों को प्रिंट करते हैं। इसके नीचे, हम 'copied_value++' रखकर 'copied_value' वेरिएबल को बढ़ाते हैं। फिर, हम 'copied_value' को बढ़ाने के बाद और 'first_value' को 'cout' का उपयोग करके प्रिंट करते हैं। इसके बाद, हम 'ReturnRefFun(first_value)' के साथ 'int& ref_value' वेरिएबल को इनिशियलाइज़ करने की मदद से रेफरेंस वापस करते हैं।
इसके बाद, हम 'my_ref' वेरिएबल का मान प्रिंट करते हैं जिसे हमने कॉपी किया था। फिर, हम 'first_value' वेरिएबल का मान प्रिंट करते हैं। इसके नीचे हम “ref_value++” डालकर “ref_value” का मान बढ़ा देते हैं। इसके नीचे, हम 'cout' की सहायता से 'ref_value' के बढ़े हुए मान और 'first_value' वेरिएबल को भी प्रिंट करते हैं। जब 'ref_value' बदला जाता है, तो 'first_value' भी बदल जाएगा।
कोड 3:
#शामिल करेंनेमस्पेस एसटीडी का उपयोग करना;
int यहाँ & ReturnRefFun ( int यहाँ & my_ref ) {
my_ref++;
वापस करना my_ref;
}
मुख्य प्रवेश बिंदु ( ) {
int यहाँ प्रथम_मूल्य = इक्कीस ;
int यहाँ प्रतिलिपि_मूल्य =ReturnRefFun ( प्रथम_मूल्य ) ;
अदालत << 'पहला मान है:' << प्रथम_मूल्य << एंडल;
अदालत << 'कॉपी किया गया मान है:' << प्रतिलिपि_मूल्य << एंडल;
Copyed_value++;
अदालत << 'copyed_value बढ़ाया गया है:' << प्रतिलिपि_मूल्य << एंडल;
अदालत << 'पहला मान :' << प्रथम_मूल्य << एंडल;
int यहाँ & Ref_value =ReturnRefFun ( प्रथम_मूल्य ) ;
अदालत << 'संदर्भ प्रतिलिपि मूल्य:' << Ref_value << एंडल;
अदालत << 'पहला मान :' << प्रथम_मूल्य << एंडल;
Ref_value++;
अदालत << 'संदर्भ मान बढ़ाया गया है:' << Ref_value << एंडल;
अदालत << 'पहला मान :' << प्रथम_मूल्य << एंडल;
वापस करना 0 ;
}
आउटपुट:
यहां पिछले कोड का परिणाम है जहां हमने 'रिटर्न रेफरेंस' तकनीक का उपयोग किया था। उदाहरण संदर्भ चर के डुप्लिकेट को वापस करने और स्वयं संदर्भ चर को वापस करने के बीच अंतर दिखाता है।
उदाहरण 4:
यहां, 'int& rByRef' को संदर्भ फ़ंक्शन के रूप में घोषित किया गया है जो संदर्भ चर लौटाता है। हम 'int& डेटा' को इस 'int& rByref()' फ़ंक्शन में पास करते हैं। यहां, हम 'डेटा' वेरिएबल का पता प्रिंट करते हैं और फिर इसके नीचे रिटर्न संदर्भ का उपयोग करते हैं। अब, हम 'मुख्य()' विधि को लागू करने के बाद 'x_var' वेरिएबल को प्रारंभ करते हैं। फिर, हम यहां '&x_var' को 'cout' में डालकर 'x_var' का पता प्रिंट करते हैं।
इसके नीचे, हम 'int& y_var' को 'rByref(x_var)' निर्दिष्ट करके संदर्भ चर का उपयोग करते हैं। फिर, हम उस '&y_var' संदर्भ चर का पता भी प्रिंट करते हैं। इसके नीचे, हम 'x_var' वेरिएबल को 'z_var' वेरिएबल में कॉपी करते हैं और इस कॉपी किए गए वेरिएबल का पता भी प्रिंट करते हैं जो कि '&z_var' है। इसके बाद, हम 'rByref()' फ़ंक्शन को कॉल करते हैं, इसके अंदर पैरामीटर के रूप में 'x_var' वेरिएबल को पास करते हैं, और इस वेरिएबल को '93' असाइन करते हैं। हम '&x_var' को 'cout' में डालकर 'x_var' का पता भी दोबारा प्रस्तुत करते हैं।
कोड 4:
#शामिल करेंनेमस्पेस एसटीडी का उपयोग करना;
int यहाँ & rByref ( int यहाँ & डेटा )
{
अदालत << 'डेटा का पता:' << & डेटा << एंडल;
वापस करना डेटा;
}
मुख्य प्रवेश बिंदु ( )
{
int x_var = 42 ;
अदालत << 'x_var का पता:' << & x_var << एंडल;
int यहाँ & y_var = rByref ( x_var ) ;
अदालत << 'y_var का पता:' << & y_var << एंडल;
int z_var = rByref ( x_var ) ;
अदालत << 'z_var का पता:' << & z_var << एंडल;
rByref ( x_var ) = 93 ;
अदालत << 'x_var का पता:' << & x_var << एंडल;
वापस करना 0 ;
}
आउटपुट:
परिणाम यह स्पष्ट करता है कि क्लोन किए गए वेरिएबल का पता, 'z_var', मूल वेरिएबल, 'x_var', संदर्भ वाले अन्य सभी स्थानों से भिन्न है।
निष्कर्ष
इस ट्यूटोरियल में 'रिटर्न रेफरेंस' अवधारणा का विस्तार से पता लगाया गया है। हमने सीखा कि 'रिटर्न रेफरेंस' C++ प्रोग्रामिंग में 'पॉइंटर्स' के समान है। हमने चर्चा की कि यह इंगित करने के लिए कि कौन सा फ़ंक्शन संदर्भ लौटाता है, फ़ंक्शन के रिटर्न प्रकार के साथ '&' प्रतीक का उपयोग करने की आवश्यकता है। हमने इस ट्यूटोरियल में कुछ उदाहरणों और उनके परिणामों का वर्णन किया है और इस अवधारणा को समझा है।