C++ இல் குறிப்பு திரும்பவும்

C Il Kurippu Tirumpavum



C++ ஆனது ஒரு மதிப்பை அல்லது முகவரியை சுட்டிகளை விட அதன் குறிப்பு மூலம் திரும்ப வழங்கும் வசதியை வழங்குகிறது. சுட்டிகளுக்குப் பதிலாக குறிப்புகளைப் பயன்படுத்துவது C++ நிரலைப் படிக்கவும் நிர்வகிக்கவும் எளிதாக்கும். C++ இல், குறிப்புகள் மற்றும் சுட்டிகள் ஒன்றுடன் ஒன்று நெருங்கிய தொடர்புடையவை. முதன்மையான வேறுபாடு என்னவென்றால், குறிப்புகள் ஒரு மாற்றுப் பெயராக இருந்தாலும், மற்றொரு மாறிக்கான 'அலியாஸ்', மதிப்புகளைச் சேர்ப்பது போன்ற செயல்பாடுகளில் சுட்டிகளைப் பயன்படுத்தலாம். குறிப்பு என்பது ஒரு மாற்றுப் பெயர் அல்லது அசல் மதிப்பின் நகல் மற்றும் “&” சின்னத்தால் குறிக்கப்படுகிறது.

எடுத்துக்காட்டு 1:

நாங்கள் 'iostream' தலைப்பு கோப்பை இறக்குமதி செய்து, பின்னர் 'std' பெயர்வெளியைப் பயன்படுத்துகிறோம். பல செயல்பாடுகள் வரையறுக்கப்பட்டுள்ளதால் தலைப்பு கோப்புகள் C++ குறியீடுகளில் இறக்குமதி செய்யப்படுகின்றன. பின்னர், செயல்பாட்டின் பெயரான 'ReturnTheValue' உடன் '&' குறியீட்டை வைப்பதன் மூலம் திரும்பும் குறிப்பு செயல்பாட்டை உருவாக்குகிறோம்.







இங்கே, 'மதிப்பு' குறிப்பு இப்போது செருகப்பட்டுள்ளது. இதன் கீழ், மதிப்பையும் முகவரியையும் “&மதிப்பு” குறிப்புடன் அச்சிடுகிறோம். பின்னர், நாங்கள் திரும்பக் குறிப்பை வைத்து 'மதிப்பு' வைக்கிறோம். இப்போது, ​​“main()” இங்கே செயல்படுத்தப்படுகிறது, மேலும் “n1” ஐ “44” மதிப்புடன் துவக்குகிறோம். இதற்குக் கீழே, “int&n2” ஆனது “returnTheValue(n1)” உடன் துவக்கப்படுகிறது. இப்போது, ​​“n1” இன் மதிப்பையும் அதன் முகவரியையும் அச்சிடுகிறோம். பின்னர், 'cout' ஐப் பயன்படுத்தி 'n2' இன் மதிப்பையும் 'n2' இன் முகவரியையும் அச்சிடுகிறோம்.



குறியீடு 1:



# அடங்கும்
பெயர்வெளி std ஐப் பயன்படுத்துதல்;
முழு எண்ணாக & மதிப்பு திரும்ப ( முழு எண்ணாக & மதிப்பு )
{
கூட் << 'மதிப்பு =' << மதிப்பு << endl
<< 'மதிப்பு முகவரி'
<< & மதிப்பு << endl;
திரும்ப மதிப்பு;
}
முழு எண்ணாக ( )
{
நீங்கள் n1 = 44 ;
முழு எண்ணாக & n2 = returnTheValue ( 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 ஐப் பயன்படுத்துதல்;
முழு எண்ணாக & MyReturnValueFunc ( முழு எண்ணாக & v1 )
{
கூட் << 'v1 இன் மதிப்பு =' << v1 << endl
<< 'v1 மாறியின் முகவரி'
<< & v1 << endl;
திரும்ப v1;
}
முழு எண்ணாக ( )
{
முழு எண்_1 = 19 ;
முழு எண்ணாக & எண்_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” மாறியின் மதிப்பை அதிகரிக்கிறோம். இதற்குக் கீழே, 'return' என்று வைக்கிறோம், இது 'my_ref' இன் குறிப்பை வழங்குகிறது.

இதற்குப் பிறகு, 'முக்கிய()' முறை இங்கே செயல்படுத்தப்படுகிறது. பின்னர், 'first_value' மாறியை '21' உடன் துவக்குவோம். இதற்குக் கீழே, 'ReturnRefFun' செயல்பாட்டில் 'first_value' ஐ வைத்து, 'copied_value' மாறியில் அதைச் சேமித்து, குறிப்பின் நகலைத் திருப்பித் தருகிறோம். பின்னர், 'cout' ஐப் பயன்படுத்தி 'first_value' மற்றும் 'copied_value' இரண்டையும் அச்சிடுவோம். இதன் கீழ், “copied_value++” ஐ வைப்பதன் மூலம் “copied_value” மாறியை அதிகரிக்கிறோம். பின்னர், 'copyed_value' ஐ அதிகரித்த பிறகு மற்றும் 'first_value' ஐ 'cout' ஐப் பயன்படுத்தி அச்சிடுவோம். இதற்குப் பிறகு, 'int& ref_value' மாறியை 'ReturnRefFun(first_value)' மூலம் துவக்குவதன் மூலம் குறிப்பைத் திருப்பித் தருகிறோம்.

இதற்குப் பிறகு, நாம் நகலெடுத்த 'my_ref' மாறியின் மதிப்பை அச்சிடுகிறோம். பின்னர், 'first_value' மாறியின் மதிப்பை அச்சிடுகிறோம். இதன் கீழ், “ref_value++” ஐ வைத்து “ref_value” இன் மதிப்பை அதிகரிக்கிறோம். இதற்குக் கீழே, 'ref_value' இன் அதிகரித்த மதிப்பையும், 'cout' உதவியுடன் 'first_value' மாறியையும் அச்சிடுகிறோம். “ref_value” மாற்றப்படும்போது, ​​“first_value” என்பதும் மாறும்.

குறியீடு 3:

# அடங்கும்
பெயர்வெளி std ஐப் பயன்படுத்துதல்;
முழு எண்ணாக & ReturnRefFun ( முழு எண்ணாக & my_ref ) {
my_ref++;
திரும்ப my_ref;
}
முழு எண்ணாக ( ) {
முழு எண்ணாக முதல்_மதிப்பு = இருபத்து ஒன்று ;
முழு எண்ணாக நகலெடுக்கப்பட்ட_மதிப்பு =ReturnRefFun ( முதல்_மதிப்பு ) ;
கூட் << 'முதல் மதிப்பு:' << முதல்_மதிப்பு << endl;
கூட் << 'நகல் செய்யப்பட்ட மதிப்பு:' << நகலெடுக்கப்பட்ட_மதிப்பு << endl;
நகலெடுக்கப்பட்ட_மதிப்பு++;
கூட் << 'நகல் செய்யப்பட்ட_மதிப்பு அதிகரிக்கப்பட்டுள்ளது:' << நகலெடுக்கப்பட்ட_மதிப்பு << endl;
கூட் << 'முதல் மதிப்பு:' << முதல்_மதிப்பு << endl;
முழு எண்ணாக & மதிப்பு_மதிப்பு =ReturnRefFun ( முதல்_மதிப்பு ) ;
கூட் << 'குறிப்பு நகலெடுக்கப்பட்ட மதிப்பு:' << மதிப்பு_மதிப்பு << endl;
கூட் << 'முதல் மதிப்பு:' << முதல்_மதிப்பு << endl;
ref_value++;
கூட் << 'குறிப்பு மதிப்பு அதிகரிக்கப்பட்டது :' << மதிப்பு_மதிப்பு << endl;
கூட் << 'முதல் மதிப்பு:' << முதல்_மதிப்பு << endl;
திரும்ப 0 ;
}


வெளியீடு:

'திரும்பக் குறிப்பு' நுட்பத்தைப் பயன்படுத்திய முந்தைய குறியீட்டின் விளைவு இங்கே உள்ளது. குறிப்பு மாறியின் நகலை திருப்பி அனுப்புவதற்கும் குறிப்பு மாறியையே திருப்பி அனுப்புவதற்கும் உள்ள வேறுபாட்டை எடுத்துக்காட்டு காட்டுகிறது.

எடுத்துக்காட்டு 4:

இங்கே, 'int& rByRef' என்பது குறிப்பு மாறியை வழங்கும் குறிப்பு செயல்பாடாக அறிவிக்கப்படுகிறது. இந்த 'int& rByref()' செயல்பாட்டிற்கு 'int& data' ஐ அனுப்புகிறோம். இங்கே, நாம் 'தரவு' மாறியின் முகவரியை அச்சிட்டு, அதற்குக் கீழே உள்ள ரிட்டர்ன் குறிப்பைப் பயன்படுத்துகிறோம். இப்போது, ​​“main()” முறையை செயல்படுத்திய பிறகு “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:

# அடங்கும்
பெயர்வெளி std ஐப் பயன்படுத்துதல்;
முழு எண்ணாக & rByref ( முழு எண்ணாக & தகவல்கள் )
{
கூட் << 'தரவின் முகவரி:' << & தகவல்கள் << endl;
திரும்ப தகவல்கள்;
}
முழு எண்ணாக ( )
{
int x_var = 42 ;
கூட் << 'x_var முகவரி:' << & x_var << endl;
முழு எண்ணாக & 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++ நிரலாக்கத்தில் உள்ள 'சுட்டிகள்' போலவே 'திரும்பக் குறிப்பு' உள்ளது என்பதை அறிந்தோம். எந்த செயல்பாடு ஒரு குறிப்பை வழங்கும் என்பதைக் குறிக்க, செயல்பாட்டின் திரும்பும் வகையுடன் “&” சின்னம் பயன்படுத்தப்பட வேண்டும் என்று நாங்கள் விவாதித்தோம். சில எடுத்துக்காட்டுகளையும் அவற்றின் விளைவுகளையும் விளக்கி, இந்த டுடோரியலில் இந்தக் கருத்தைப் புரிந்துகொண்டோம்.