Ang C++ ay nagbibigay ng pasilidad upang ibalik ang isang halaga o isang address sa pamamagitan ng sanggunian nito sa halip na mga pointer. Ang paggamit ng mga reference sa halip na mga pointer ay maaaring gawing mas simple ang isang C++ program na basahin at pamahalaan. Sa C++, ang mga reference at pointer ay malapit na nauugnay sa isa't isa. Ang pangunahing pagkakaiba ay na bagama't ang mga sanggunian ay isang kahaliling pangalan lamang, 'alias' para sa isa pang variable, ang mga pointer ay maaaring gamitin sa mga operasyon tulad ng pagdaragdag ng mga halaga. Ang reference ay isang kahaliling pangalan o duplicate ng orihinal na value at tinutukoy ng simbolo na “&”.
Halimbawa 1:
Ini-import namin ang 'iostream' na header file at pagkatapos ay ginagamit ang 'std' namespace. Ang mga file ng header ay ini-import sa mga C++ na code dahil maraming mga function ang tinukoy. Pagkatapos, lumikha kami ng isang function ng return reference sa pamamagitan ng paglalagay ng simbolo na '&' na may pangalan ng function, 'returnTheValue'.
Dito, ang sanggunian na 'halaga' ay ipinasok na ngayon. Sa ilalim nito, ipi-print namin ang value at ang address na may reference na '&value'. Pagkatapos, inilalagay namin ang return reference at inilalagay ang 'halaga'. Ngayon, ang 'pangunahing ()' ay tinatawag dito, at sinisimulan namin ang 'n1' na may halaga na '44'. Sa ibaba nito, ang 'int& n2' ay pinasimulan ng 'returnTheValue(n1)'. Ngayon, nai-print namin ang halaga ng 'n1' pati na rin ang address nito. Pagkatapos, i-print namin ang halaga ng 'n2' pati na rin ang address ng 'n2' sa pamamagitan ng paggamit ng 'cout'.
Code 1:
#include
gamit ang namespace std;
int at returnTheValue ( int at halaga )
{
cout << 'Halaga = ' << halaga << endl
<< ' Ang address ng halaga ay '
<< at halaga << endl;
bumalik halaga;
}
int pangunahing ( )
{
ikaw n1 = 44 ;
int at n2 = returnTheValue ( n1 ) ;
cout << 'n1 = ' << n1 << endl
<< 'Ang address ng n1 ay'
<< at n1 << endl;
cout << 'n2 =' << n2 << endl
<< 'Ang address ng n2 ay'
<< at n2 << endl;
bumalik 0 ;
}
Output:
Dito, maaari naming tandaan na ang isang reference ay isang kahaliling pangalan lamang ng isa pang variable tulad ng ipinapakita sa sumusunod. Bilang address ng halaga, ang 'n1' at 'n2' ay hindi nagbabago.
Halimbawa 2:
Ginagamit namin ang 'std' namespace pagkatapos i-import ang 'iostream' header file. Susunod, ginagamit namin ang pangalan ng function na 'MyReturnValueFunc' at ang simbolo ng '&' upang bumuo ng isang function ng return reference. Ang reference sa variable na 'v1' ay inilalagay dito. Ini-print namin ang halaga at ang address na may reference na '&v1' sa ilalim nito. Susunod, ilalagay namin ang 'return reference' sa pamamagitan ng paggamit ng 'return' at 'v1' sa lokasyong ito. Dito, ang 'main()' ay tinatawag, at ang 'num_1' ay pinasimulan sa halagang '19'. Ang pagsisimula ng “int& num_2” ay ginagawa gamit ang “MyReturnValueFunc(num_1)”.
Sa kasalukuyan, ini-print namin ang halaga at address ng 'num_1' at, gamit ang 'cout', ini-print namin ang halaga at address ng 'num_2'. Binabago namin ngayon ang halaga ng 'num_1' sa pamamagitan ng paggamit ng address na ibinalik dito ng 'MyReturnValueFunc'. Ibinabalik ng function na ito ang kahaliling pangalan ng “v1” na siyang kahaliling pangalan din ng “num_1”. Kaya, binabago namin ang halaga nito at itinakda ito sa '91'. Itinalaga namin ang '91' sa 'MyReturnValueFunc(num_1)' na nagsisilbing alias dito. Pagkatapos, i-print namin muli ang halaga at ang address ng 'num_1'.
Code 2:
#includegamit ang namespace std;
int at MyReturnValueFunc ( int at v1 )
{
cout << 'Ang halaga ng v1 = ' << v1 << endl
<< ' Ang address ng v1 variable ay '
<< at v1 << endl;
bumalik v1;
}
int pangunahing ( )
{
int num_1 = 19 ;
int at num_2 = MyReturnValueFunc ( num_1 ) ;
cout << 'Ang halaga ng num_1 = ' << num_1 << endl
<< ' Ang address ng num_1 ay '
<< at num_1 << endl;
cout << 'Ang halaga ng num_2 = ' << num_2 << endl
<< ' Ang address ng num_2 ay '
<< at num_2 << endl;
MyReturnValueFunc ( num_1 ) = 91 ;
cout << 'Ngayon, ang halaga ng num_1 = ' << num_1 << endl
<< 'Ang address ng num_1 ay '
<< at num_1 << endl;
bumalik 0 ;
}
Output:
Tulad ng ipinakita sa mga sumusunod, makikita natin na ang isang sanggunian ay isang alternatibong pangalan lamang para sa isa pang variable dahil ang address ng mga halaga ng 'v1', 'num_1', at 'num_2' ay nanatiling pare-pareho:
Halimbawa 3:
Ang 'iostream' header file ay na-import at ang 'std' namespace ay ginagamit. Dahil maraming function ang tinukoy sa mga file ng header, ini-import namin ang mga ito sa mga C++ code. Dito, gumawa kami ng function na 'ReturnRefFun()' kung saan inilalagay namin ang 'int& my_ref' na nagbabalik ng reference. Ang 'int& ReturnRefFun' ay idineklara dito bilang reference function. Pagkatapos nito, dinadagdagan namin ang halaga ng variable na 'my_ref'. Sa ilalim nito, inilalagay namin ang 'return' na nagbabalik ng reference ng 'my_ref'.
Pagkatapos nito, ang 'pangunahing()' na pamamaraan ay ginagamit dito. Pagkatapos, sinisimulan namin ang variable na 'first_value' na may '21'. Sa ibaba nito, ibinabalik namin ang kopya ng reference sa pamamagitan ng paglalagay ng “first_value” sa function na “ReturnRefFun” at i-save ito sa variable na “copied_value”. Pagkatapos, ipi-print namin pareho ang 'first_value' pati na rin ang 'copied_value' sa pamamagitan ng paggamit ng 'cout'. Sa ilalim nito, dinaragdagan namin ang variable na 'copied_value' sa pamamagitan ng paglalagay ng 'copied_value++'. Pagkatapos, ipi-print namin ang “copied_value” pagkatapos itong dagdagan at ang “first_value” gamit ang “cout”. Pagkatapos nito, ibinabalik namin ang reference sa tulong ng pagsisimula ng variable na 'int& ref_value' gamit ang 'ReturnRefFun(first_value)'.
Pagkatapos nito, nai-print namin ang halaga ng variable na 'my_ref' na kinopya namin. Pagkatapos, ipi-print namin ang halaga ng variable na 'first_value'. Sa ilalim nito, dinaragdagan namin ang halaga ng “ref_value” sa pamamagitan ng paglalagay ng “ref_value++”. Sa ibaba nito, ini-print namin ang incremented na halaga ng 'ref_value' at gayundin ang variable na 'first_value' sa tulong ng 'cout'. Kapag ang “ref_value” ay binago, ang “first_value” ay magbabago din.
Code 3:
#includegamit ang namespace std;
int at ReturnRefFun ( int at my_ref ) {
my_ref++;
bumalik my_ref;
}
int pangunahing ( ) {
int first_value = dalawampu't isa ;
int copy_value =ReturnRefFun ( first_value ) ;
cout << 'Ang unang halaga ay: ' << first_value << endl;
cout << 'Ang kinopyang halaga ay : ' << copy_value << endl;
copy_value++;
cout << 'Ang kinopyang_halaga ay nadagdagan: ' << copy_value << endl;
cout << 'Ang unang halaga : ' << first_value << endl;
int at ref_value =ReturnRefFun ( first_value ) ;
cout << 'Ang reference na kinopyang halaga: ' << ref_value << endl;
cout << 'Ang unang halaga : ' << first_value << endl;
ref_value++;
cout << 'Ang reference na halaga ay dinagdagan : ' << ref_value << endl;
cout << 'Ang unang halaga : ' << first_value << endl;
bumalik 0 ;
}
Output:
Narito ang kinalabasan ng nakaraang code kung saan ginamit namin ang diskarteng 'return reference'. Ipinapakita ng halimbawa ang pagkakaiba sa pagitan ng pagbabalik ng duplicate ng reference variable at pagbabalik ng reference variable mismo.
Halimbawa 4:
Dito, ang 'int& rByRef' ay idineklara bilang reference function na nagbabalik ng reference variable. Ipinapasa namin ang “int& data” sa function na “int& rByref()” na ito. Dito, ipi-print namin ang address ng variable na 'data' at pagkatapos ay ginagamit ang return reference sa ibaba nito. Ngayon, sinisimulan namin ang variable na 'x_var' pagkatapos gamitin ang 'pangunahing()' na pamamaraan. Pagkatapos, i-print namin ang address ng 'x_var' dito sa pamamagitan ng paglalagay ng '&x_var' sa 'cout'.
Sa ilalim nito, ginagamit namin ang reference na variable sa pamamagitan ng pagtatalaga ng “rByref(x_var)” sa “int& y_var”. Pagkatapos, ipi-print din namin ang address ng reference na variable na '&y_var'. Sa ibaba nito, kinokopya namin ang variable na 'x_var' sa variable na 'z_var' at ipi-print din ang address ng nakopyang variable na ito na '&z_var'. Pagkatapos nito, tinawag namin ang function na 'rByref()', ipasa ang variable na 'x_var' bilang parameter sa loob nito, at italaga ang '93' sa variable na ito. Ire-render din namin muli ang address ng “x_var” sa pamamagitan ng paglalagay ng “&x_var” sa “cout”.
Code 4:
#includegamit ang namespace std;
int at rByref ( int at datos )
{
cout << 'Address ng data: ' << at datos << endl;
bumalik data;
}
int pangunahing ( )
{
int x_var = 42 ;
cout << 'Address ng x_var: ' << at x_var << endl;
int at y_var = rByref ( x_var ) ;
cout << 'Address ng y_var: ' << at y_var << endl;
int z_var = rByref ( x_var ) ;
cout << 'Address ng z_var: ' << at z_var << endl;
rByref ( x_var ) = 93 ;
cout << 'Address ng x_var: ' << at x_var << endl;
bumalik 0 ;
}
Output:
Nilinaw ng resulta na ang address ng naka-clone na variable, 'z_var', ay naiiba sa lahat ng iba pang mga lokasyon na tinutukoy ng orihinal na variable, 'x_var'.
Konklusyon
Ang konsepto ng 'return reference' ay ginalugad sa tutorial na ito nang detalyado. Nalaman namin na ang 'return reference' ay katulad ng 'pointers' sa C++ programming. Tinalakay namin na para isaad kung aling function ang nagbabalik ng reference, kailangang gamitin ang simbolong '&' kasama ang uri ng pagbabalik ng function. Inilarawan namin ang ilang mga halimbawa at ang kanilang mga kinalabasan at naunawaan ang konseptong ito sa tutorial na ito.