C++ nudi možnost vrnitve vrednosti ali naslova po sklicu in ne po kazalcih. Uporaba referenc namesto kazalcev lahko olajša branje in upravljanje programa C++. V C++ so reference in kazalci med seboj tesno povezani. Primarna razlika je v tem, da čeprav so reference le nadomestno ime, »vzdevek« za drugo spremenljivko, se kazalci lahko uporabljajo v operacijah, kot je dodajanje vrednosti. Sklic je nadomestno ime ali dvojnik izvirne vrednosti in je označen s simbolom »&«.
Primer 1:
Uvozimo datoteko glave »iostream« in nato uporabimo imenski prostor »std«. Datoteke glave so uvožene v kodah C++, saj je definiranih veliko funkcij. Nato ustvarimo povratno referenčno funkcijo tako, da simbol »&« postavimo z imenom funkcije, »returnTheValue«.
Tukaj je zdaj vstavljen sklic 'vrednost'. Pod tem natisnemo vrednost in naslov s sklicem »&value«. Nato postavimo povratni sklic in postavimo »vrednost«. Zdaj se tukaj prikliče 'main()' in inicializiramo 'n1' z vrednostjo '44'. Pod tem se »int& n2« inicializira z »returnTheValue(n1)«. Zdaj natisnemo vrednost 'n1' in njegov naslov. Nato natisnemo vrednost »n2« in naslov »n2« z uporabo »cout«.
Koda 1:
#include
uporaba imenskega prostora std;
int & returnTheValue ( int & vrednost )
{
cout << 'Vrednost = ' << vrednost << konec
<< ' Naslov vrednosti je '
<< & vrednost << endl;
vrnitev vrednost;
}
int main ( )
{
ti n1 = 44 ;
int & n2 = vrniVrednost ( n1 ) ;
cout << 'n1 = ' << n1 << konec
<< ' Naslov n1 je '
<< & n1 << endl;
cout << 'n2 = ' << n2 << konec
<< ' Naslov n2 je '
<< & n2 << endl;
vrnitev 0 ;
}
Izhod:
Tu lahko opazimo, da je sklic le nadomestno ime druge spremenljivke, kot je prikazano v nadaljevanju. Kot naslova vrednosti se »n1« in »n2« nikoli ne spremenita.
Primer 2:
Imenski prostor »std« uporabljamo po uvozu datoteke glave »iostream«. Nato uporabimo ime funkcije 'MyReturnValueFunc' in simbol '&', da zgradimo referenčno funkcijo povratka. Tukaj je sklic na spremenljivko »v1«. Natisnemo vrednost in naslov s sklicem »&v1« pod tem. Nato vstavimo 'povratni sklic', tako da na tem mestu uporabimo 'vrnitev' in 'v1'. Tukaj se pokliče »main()« in »num_1« se inicializira z vrednostjo »19«. Inicializacija »int& num_2« se izvede z »MyReturnValueFunc(num_1)«.
Trenutno natisnemo vrednost in naslov »num_1« in z uporabo »cout« natisnemo vrednost in naslov »num_2«. Zdaj spremenimo vrednost »num_1« z uporabo naslova, ki ga tukaj vrne »MyReturnValueFunc«. Ta funkcija vrne nadomestno ime »v1«, ki je tudi nadomestno ime »num_1«. Torej, spremenimo njegovo vrednost in jo nastavimo na '91'. »91« dodelimo »MyReturnValueFunc(num_1)«, ki tukaj deluje kot vzdevek. Nato znova natisnemo vrednost in naslov »num_1«.
Koda 2:
#includeuporaba imenskega prostora std;
int & MyReturnValueFunc ( int & v1 )
{
cout << 'Vrednost v1 = ' << v1 << konec
<< ' Naslov spremenljivke v1 je '
<< & v1 << endl;
vrnitev v1;
}
int main ( )
{
int num_1 = 19 ;
int & num_2 = MyReturnValueFunc ( št_1 ) ;
cout << 'Vrednost num_1 = ' << št_1 << konec
<< ' Naslov num_1 je '
<< & št_1 << endl;
cout << 'Vrednost num_2 = ' << št_2 << konec
<< ' Naslov num_2 je '
<< & št_2 << endl;
MyReturnValueFunc ( št_1 ) = 91 ;
cout << 'Zdaj, vrednost num_1 = ' << št_1 << konec
<< 'Naslov num_1 je '
<< & št_1 << endl;
vrnitev 0 ;
}
Izhod:
Kot je prikazano v nadaljevanju, lahko vidimo, da je sklic zgolj alternativno ime za drugo spremenljivko, saj je naslov vrednosti »v1«, »num_1« in »num_2« ostal nespremenjen:
Primer 3:
Datoteka glave »iostream« je uvožena in uporabljen je imenski prostor »std«. Ker so številne funkcije določene v datotekah glave, jih uvozimo v kode C++. Tukaj ustvarimo funkcijo »ReturnRefFun()«, v katero postavimo »int& my_ref«, ki vrne sklic. »int& ReturnRefFun« je tukaj deklarirana kot referenčna funkcija. Po tem povečamo vrednost spremenljivke 'my_ref'. Pod tem smo postavili 'return', ki vrne referenco 'my_ref'.
Po tem se tukaj prikliče metoda »main()«. Nato inicializiramo spremenljivko 'first_value' z '21'. Pod tem vrnemo kopijo sklica tako, da postavimo »first_value« v funkcijo »ReturnRefFun« in jo shranimo v spremenljivko »copied_value«. Nato natisnemo tako »first_value« kot tudi »copied_value« z uporabo »cout«. Pod tem povečamo spremenljivko 'copied_value' tako, da postavimo 'copied_value++'. Nato natisnemo »copied_value«, potem ko jo povečamo, in »first_value« z uporabo »cout«. Po tem vrnemo referenco s pomočjo inicializacije spremenljivke “int& ref_value” z “ReturnRefFun(first_value)”.
Po tem natisnemo vrednost spremenljivke “my_ref”, ki smo jo kopirali. Nato natisnemo vrednost spremenljivke “first_value”. Pod tem povečamo vrednost »ref_value« tako, da vnesemo »ref_value++«. Pod tem natisnemo povečano vrednost 'ref_value' in tudi spremenljivko 'first_value' s pomočjo 'cout'. Ko se spremeni 'ref_value', se spremeni tudi 'first_value'.
Koda 3:
#includeuporaba imenskega prostora std;
int & ReturnRefFun ( int & moj_ref ) {
moj_ref++;
vrnitev moj_ref;
}
int main ( ) {
int prva_vrednost = enaindvajset ;
int kopirana_vrednost =ReturnRefFun ( prva_vrednost ) ;
cout << 'Prva vrednost je:' << prva_vrednost << endl;
cout << 'Kopirana vrednost je: ' << kopirana_vrednost << endl;
kopirana_vrednost++;
cout << 'Copied_value se poveča: ' << kopirana_vrednost << endl;
cout << 'Prva vrednost:' << prva_vrednost << endl;
int & ref_value =ReturnRefFun ( prva_vrednost ) ;
cout << 'Referenčna kopirana vrednost: ' << ref_value << endl;
cout << 'Prva vrednost:' << prva_vrednost << endl;
ref_value++;
cout << 'Referenčna vrednost se poveča: ' << ref_value << endl;
cout << 'Prva vrednost:' << prva_vrednost << endl;
vrnitev 0 ;
}
Izhod:
Tukaj je rezultat prejšnje kode, kjer smo uporabili tehniko »povratne reference«. Primer prikazuje razliko med vračanjem dvojnika referenčne spremenljivke in vračanjem same referenčne spremenljivke.
Primer 4:
Tukaj je »int& rByRef« deklarirana kot referenčna funkcija, ki vrne referenčno spremenljivko. Tej funkciji »int& rByref()« posredujemo »int& podatke«. Tukaj natisnemo naslov spremenljivke »data« in nato pod tem uporabimo povratni sklic. Zdaj inicializiramo spremenljivko 'x_var' po priklicu metode 'main()'. Nato tukaj natisnemo naslov »x_var« tako, da »&x_var« vstavimo v »cout«.
Pod tem uporabimo referenčno spremenljivko tako, da dodelimo 'rByref(x_var)' 'int& y_var'. Nato natisnemo tudi naslov te referenčne spremenljivke »&y_var«. Pod tem kopiramo spremenljivko “x_var” v spremenljivko “z_var” in natisnemo tudi naslov te kopirane spremenljivke, ki je “&z_var”. Po tem pokličemo funkcijo 'rByref()', posredujemo spremenljivko 'x_var' kot parameter v njej in tej spremenljivki dodelimo '93'. Prav tako ponovno upodobimo naslov »x_var«, tako da vstavimo »&x_var« v »cout«.
Koda 4:
#includeuporaba imenskega prostora std;
int & rByref ( int & podatke )
{
cout << 'Naslov podatkov: ' << & podatke << endl;
vrnitev podatki;
}
int main ( )
{
int x_var = 42 ;
cout << 'Naslov x_var: ' << & x_var << endl;
int & y_var = rByref ( x_var ) ;
cout << 'Naslov y_var: ' << & y_var << endl;
int z_var = rByref ( x_var ) ;
cout << 'Naslov z_var: ' << & z_var << endl;
rByref ( x_var ) = 93 ;
cout << 'Naslov x_var: ' << & x_var << endl;
vrnitev 0 ;
}
Izhod:
Rezultat jasno pokaže, da se naslov klonirane spremenljivke, »z_var«, razlikuje od vseh drugih lokacij, na katere se sklicuje izvirna spremenljivka, »x_var«.
Zaključek
Koncept 'povratne reference' je v tej vadnici podrobno raziskan. Izvedeli smo, da je 'povratna referenca' podobna 'kazalcem' v programiranju C++. Razpravljali smo o tem, da je treba za navedbo, katera funkcija vrne referenco, uporabiti simbol »&« pri vrnitvi funkcije. V tej vadnici smo ilustrirali nekaj primerov in njihove rezultate ter razumeli ta koncept.