C++ పాయింటర్‌ల కంటే దాని సూచన ద్వారా విలువ లేదా చిరునామాను తిరిగి ఇచ్చే సదుపాయాన్ని అందిస్తుంది. పాయింటర్‌లకు బదులుగా రిఫరెన్స్‌లను ఉపయోగించడం వల్ల C++ ప్రోగ్రామ్‌ని చదవడం మరియు నిర్వహించడం సులభం అవుతుంది. C++లో, సూచనలు మరియు పాయింటర్‌లు ఒకదానికొకటి దగ్గరి సంబంధం కలిగి ఉంటాయి. ప్రాథమిక వ్యత్యాసం ఏమిటంటే, సూచనలు కేవలం ప్రత్యామ్నాయ పేరు అయినప్పటికీ, మరొక వేరియబుల్ కోసం “అలియాస్”, విలువలను జోడించడం వంటి ఆపరేషన్‌లలో పాయింటర్‌లను ఉపయోగించవచ్చు. సూచన అనేది ప్రత్యామ్నాయ పేరు లేదా అసలు విలువ యొక్క నకిలీ మరియు ఇది “&” చిహ్నంతో సూచించబడుతుంది.
ఉదాహరణ 1:
మేము “iostream” హెడర్ ఫైల్‌ను దిగుమతి చేసి, ఆపై “std” నేమ్‌స్పేస్‌ని ఉపయోగిస్తాము. అనేక విధులు నిర్వచించబడినందున హెడర్ ఫైల్‌లు C++ కోడ్‌లలో దిగుమతి చేయబడతాయి. అప్పుడు, మేము ఫంక్షన్ పేరుతో '&' చిహ్నాన్ని ఉంచడం ద్వారా రిటర్న్ రిఫరెన్స్ ఫంక్షన్‌ను సృష్టిస్తాము, 'returnTheValue'.
ఇక్కడ, 'విలువ' సూచన ఇప్పుడు చొప్పించబడింది. దీని కింద, మేము విలువ మరియు చిరునామాను “&విలువ” సూచనతో ముద్రిస్తాము. అప్పుడు, మేము రిటర్న్ రిఫరెన్స్ను ఉంచుతాము మరియు 'విలువ' ఉంచండి. ఇప్పుడు, “main()” ఇక్కడ ప్రారంభించబడింది మరియు మేము “44” విలువతో “n1”ని ప్రారంభిస్తాము. దీని క్రింద, “int&n2” “returnTheValue(n1)”తో ప్రారంభించబడింది. ఇప్పుడు, మేము “n1” విలువను అలాగే దాని చిరునామాను ప్రింట్ చేస్తాము. అప్పుడు, మేము 'cout'ని ఉపయోగించడం ద్వారా 'n2' విలువను అలాగే 'n2' చిరునామాను ముద్రిస్తాము.
కోడ్ 1:
#
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
int & విలువను తిరిగి ఇవ్వండి ( int & విలువ )
{
కోట్ << 'విలువ =' << విలువ << endl
<< 'విలువ చిరునామా'
<< & విలువ << endl;
తిరిగి విలువ;
}
పూర్ణాంక ప్రధాన ( )
{
మీరు n1 = 44 ;
int & n2 = రిటర్న్TheValue ( n1 ) ;
కోట్ << 'n1 =' << n1 << endl
<< 'n1 చిరునామా'
<< & n1 << endl;
కోట్ << 'n2 =' << n2 << endl
<< 'n2 చిరునామా'
<< & n2 << endl;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇక్కడ, కింది వాటిలో చూపిన విధంగా సూచన అనేది మరొక వేరియబుల్ యొక్క ప్రత్యామ్నాయ పేరు మాత్రమే అని మేము గమనించవచ్చు. విలువ యొక్క చిరునామాగా, “n1” మరియు “n2” ఎప్పటికీ మారవు.
ఉదాహరణ 2:
“iostream” హెడర్ ఫైల్‌ను దిగుమతి చేసిన తర్వాత మేము “std” నేమ్‌స్పేస్‌ని ఉపయోగిస్తాము. తరువాత, రిటర్న్ రిఫరెన్స్ ఫంక్షన్‌ను రూపొందించడానికి మేము ఫంక్షన్ పేరు “MyReturnValueFunc” మరియు “&” చిహ్నాన్ని ఉపయోగిస్తాము. 'v1' వేరియబుల్ యొక్క సూచన ఇక్కడ ఉంచబడింది. మేము దీని క్రింద ఉన్న “&v1” సూచనతో విలువ మరియు చిరునామాను ప్రింట్ చేస్తాము. తరువాత, మేము ఈ స్థానంలో 'రిటర్న్' మరియు 'v1'ని ఉపయోగించడం ద్వారా 'రిటర్న్ రిఫరెన్స్'ని ఇన్సర్ట్ చేస్తాము. ఇక్కడ, “main()” అని పిలుస్తారు మరియు “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:
#నేమ్‌స్పేస్ stdని ఉపయోగించడం;
int & MyReturnValueFunc ( int & v1 )
{
కోట్ << 'v1 విలువ =' << v1 << endl
<< 'v1 వేరియబుల్ చిరునామా'
<< & v1 << endl;
తిరిగి v1;
}
పూర్ణాంక ప్రధాన ( )
{
పూర్ణ సంఖ్య_1 = 19 ;
int & num_2 = MyReturnValueFunc ( సంఖ్య_1 ) ;
కోట్ << 'సంఖ్య_1 విలువ =' << సంఖ్య_1 << endl
<< 'సంఖ్య_1 చిరునామా'
<< & సంఖ్య_1 << endl;
కోట్ << 'సంఖ్య_2 విలువ =' << సంఖ్య_2 << endl
<< 'సంఖ్య_2 చిరునామా'
<< & సంఖ్య_2 << endl;
MyReturnValueFunc ( సంఖ్య_1 ) = 91 ;
కోట్ << 'ఇప్పుడు, num_1 విలువ = ' << సంఖ్య_1 << endl
<< 'సంఖ్య_1 యొక్క చిరునామా '
<< & సంఖ్య_1 << endl;
తిరిగి 0 ;
}
అవుట్‌పుట్:
కింది వాటిలో ప్రదర్శించినట్లుగా, “v1”, “num_1” మరియు “num_2” విలువల చిరునామా స్థిరంగా ఉన్నందున సూచన అనేది మరొక వేరియబుల్‌కు ప్రత్యామ్నాయ పేరు మాత్రమే అని మనం చూడవచ్చు:
ఉదాహరణ 3:
“iostream” హెడర్ ఫైల్ దిగుమతి చేయబడింది మరియు “std” నేమ్‌స్పేస్ ఉపయోగించబడుతుంది. హెడర్ ఫైల్‌లలో అనేక విధులు పేర్కొనబడినందున, మేము వాటిని C++ కోడ్‌లలోకి దిగుమతి చేస్తాము. ఇక్కడ, మేము 'ReturnRefFun()' ఫంక్షన్‌ని సృష్టిస్తాము, దీనిలో మేము సూచనను అందించే 'int& my_ref'ని ఉంచుతాము. 'int& ReturnRefFun' ఇక్కడ రిఫరెన్స్ ఫంక్షన్‌గా ప్రకటించబడింది. దీని తరువాత, మేము 'my_ref' వేరియబుల్ విలువను పెంచుతాము. దీని కింద, 'my_ref' యొక్క సూచనను అందించే 'రిటర్న్' అని ఉంచాము.
దీని తరువాత, 'ప్రధాన ()' పద్ధతి ఇక్కడ ప్రారంభించబడింది. అప్పుడు, మేము '21'తో 'first_value' వేరియబుల్‌ని ప్రారంభిస్తాము. దీని క్రింద, మేము 'ReturnRefFun' ఫంక్షన్‌లో 'first_value'ని ఉంచడం ద్వారా సూచన కాపీని తిరిగి అందిస్తాము మరియు దానిని 'copied_value' వేరియబుల్‌లో సేవ్ చేస్తాము. అప్పుడు, మేము 'cout'ని ఉపయోగించడం ద్వారా 'first_value' అలాగే 'copied_value' రెండింటినీ ప్రింట్ చేస్తాము. దీని కింద, “copied_value++”ని ఉంచడం ద్వారా మేము “copied_value” వేరియబుల్‌ని పెంచుతాము. అప్పుడు, మేము దానిని పెంచిన తర్వాత “copied_value”ని మరియు “cout”ని ఉపయోగించి “first_value”ని ప్రింట్ చేస్తాము. దీని తర్వాత, 'ReturnRefFun(first_value)'తో 'int& ref_value' వేరియబుల్‌ని ప్రారంభించడం ద్వారా మేము సూచనను తిరిగి ఇస్తాము.
దీని తరువాత, మేము కాపీ చేసిన “my_ref” వేరియబుల్ విలువను ముద్రిస్తాము. అప్పుడు, మేము 'first_value' వేరియబుల్ యొక్క విలువను ముద్రిస్తాము. దీని కింద, మేము “ref_value++”ని ఉంచడం ద్వారా “ref_value” విలువను పెంచుతాము. దీని క్రింద, మేము 'ref_value' యొక్క పెరిగిన విలువను మరియు 'cout' సహాయంతో 'first_value' వేరియబుల్‌ను కూడా ముద్రిస్తాము. “ref_value” మారినప్పుడు, “first_value” కూడా మారుతుంది.
కోడ్ 3:
#నేమ్‌స్పేస్ stdని ఉపయోగించడం;
int & రిటర్న్ రిఫ్ఫన్ ( int & నా_ref ) {
my_ref++;
తిరిగి నా_ref;
}
పూర్ణాంక ప్రధాన ( ) {
int మొదటి_విలువ = ఇరవై ఒకటి ;
int కాపీ చేయబడిన_విలువ =ReturnRefFun ( మొదటి_విలువ ) ;
కోట్ << 'మొదటి విలువ:' << మొదటి_విలువ << endl;
కోట్ << 'కాపీ చేయబడిన విలువ: ' << కాపీ చేయబడిన_విలువ << endl;
కాపీ చేసిన_విలువ++;
కోట్ << 'copied_value పెంచబడింది: ' << కాపీ చేయబడిన_విలువ << endl;
కోట్ << 'మొదటి విలువ :' << మొదటి_విలువ << endl;
int & ref_value =ReturnRefFun ( మొదటి_విలువ ) ;
కోట్ << 'రిఫరెన్స్ కాపీ చేయబడిన విలువ:' << ref_value << endl;
కోట్ << 'మొదటి విలువ :' << మొదటి_విలువ << endl;
ref_value++;
కోట్ << 'సూచన విలువ పెరిగింది : ' << ref_value << endl;
కోట్ << 'మొదటి విలువ :' << మొదటి_విలువ << endl;
తిరిగి 0 ;
}
అవుట్‌పుట్:
మేము 'రిటర్న్ రిఫరెన్స్' టెక్నిక్‌ని ఉపయోగించిన మునుపటి కోడ్ యొక్క ఫలితం ఇక్కడ ఉంది. ఉదాహరణ రిఫరెన్స్ వేరియబుల్ యొక్క నకిలీని తిరిగి ఇవ్వడం మరియు రిఫరెన్స్ వేరియబుల్‌ను తిరిగి ఇవ్వడం మధ్య వ్యత్యాసాన్ని చూపుతుంది.
ఉదాహరణ 4:
ఇక్కడ, “int& rByRef” అనేది రిఫరెన్స్ వేరియబుల్‌ని అందించే రిఫరెన్స్ ఫంక్షన్‌గా ప్రకటించబడింది. మేము ఈ 'int& rByref()' ఫంక్షన్‌కి 'int& డేటా'ని పాస్ చేస్తాము. ఇక్కడ, మేము 'డేటా' వేరియబుల్ యొక్క చిరునామాను ప్రింట్ చేస్తాము మరియు దీని క్రింద ఉన్న రిటర్న్ రిఫరెన్స్ను ఉపయోగిస్తాము. ఇప్పుడు, మేము “main()” పద్ధతిని ప్రారంభించిన తర్వాత “x_var” వేరియబుల్‌ని ప్రారంభిస్తాము. అప్పుడు, 'కౌట్'లో '&x_var'ని ఉంచడం ద్వారా మేము ఇక్కడ 'x_var' చిరునామాను ప్రింట్ చేస్తాము.
దీని కింద, “int& y_var”కి “rByref(x_var)”ని కేటాయించడం ద్వారా మేము రిఫరెన్స్ వేరియబుల్‌ని ఉపయోగిస్తాము. అప్పుడు, మేము ఆ “&y_var” రిఫరెన్స్ వేరియబుల్ చిరునామాను కూడా ప్రింట్ చేస్తాము. దీని క్రింద, మేము “x_var” వేరియబుల్‌ను “z_var” వేరియబుల్‌లోకి కాపీ చేస్తాము మరియు “&z_var” అయిన ఈ కాపీ చేయబడిన వేరియబుల్ చిరునామాను కూడా ప్రింట్ చేస్తాము. దీని తరువాత, మేము “rByref()” ఫంక్షన్‌ని పిలుస్తాము, “x_var” వేరియబుల్‌ను దాని లోపల ఉన్న పారామీటర్‌గా పాస్ చేస్తాము మరియు ఈ వేరియబుల్‌కు “93”ని కేటాయించండి. 'కౌట్'లో '&x_var'ని ఉంచడం ద్వారా మేము మళ్లీ 'x_var' చిరునామాను కూడా అందిస్తాము.
కోడ్ 4:
#నేమ్‌స్పేస్ stdని ఉపయోగించడం;
int & rByref ( int & సమాచారం )
{
కోట్ << 'డేటా చిరునామా:' << & సమాచారం << endl;
తిరిగి సమాచారం;
}
పూర్ణాంక ప్రధాన ( )
{
int x_var = 42 ;
కోట్ << 'x_var చిరునామా:' << & x_var << endl;
int & y_var = rByref ( x_var ) ;
కోట్ << 'y_var చిరునామా:' << & y_var << endl;
int z_var = rByref ( x_var ) ;
కోట్ << 'z_var చిరునామా:' << & z_var << endl;
rByref ( x_var ) = 93 ;
కోట్ << 'x_var చిరునామా:' << & x_var << endl;
తిరిగి 0 ;
}
అవుట్‌పుట్:
క్లోన్ చేయబడిన వేరియబుల్ యొక్క చిరునామా, “z_var”, ఒరిజినల్ వేరియబుల్ “x_var” రెఫరెన్స్‌ల అన్ని ఇతర స్థానాల నుండి భిన్నంగా ఉంటుందని ఫలితం స్పష్టం చేస్తుంది.
ముగింపు
'రిటర్న్ రిఫరెన్స్' కాన్సెప్ట్ ఈ ట్యుటోరియల్‌లో వివరంగా అన్వేషించబడింది. 'రిటర్న్ రిఫరెన్స్' అనేది C++ ప్రోగ్రామింగ్‌లోని 'పాయింటర్స్' లాగానే ఉంటుందని మేము తెలుసుకున్నాము. ఏ ఫంక్షన్ రిఫరెన్స్‌ని రిటర్న్ చేస్తుందో సూచించడానికి, ఫంక్షన్ యొక్క రిటర్న్ రకంతో “&” చిహ్నాన్ని ఉపయోగించాలని మేము చర్చించాము. మేము కొన్ని ఉదాహరణలు మరియు వాటి ఫలితాలను వివరించాము మరియు ఈ ట్యుటోరియల్‌లో ఈ భావనను అర్థం చేసుకున్నాము.