Návratová reference v C++

Navratova Reference V C



C++ poskytuje možnost vrátit hodnotu nebo adresu pomocí jejího odkazu, nikoli ukazatelů. Použití odkazů místo ukazatelů může usnadnit čtení a správu programu C++. V C++ spolu odkazy a ukazatele úzce souvisejí. Primární rozdíl spočívá v tom, že ačkoli jsou odkazy pouze alternativním názvem, „alias“ pro jinou proměnnou, ukazatele lze použít při operacích, jako je sčítání hodnot. Odkaz je alternativní název nebo duplikát původní hodnoty a je označen symbolem „&“.

Příklad 1:

Importujeme soubor záhlaví „iostream“ a poté použijeme jmenný prostor „std“. Soubory záhlaví jsou importovány v kódech C++, protože je definováno mnoho funkcí. Poté vytvoříme funkci návratové reference umístěním symbolu „&“ s názvem funkce „returnTheValue“.







Zde je nyní vložen odkaz „hodnota“. Pod tím vytiskneme hodnotu a adresu s odkazem „&value“. Poté umístíme návratovou referenci a umístíme „hodnotu“. Nyní se zde vyvolá „main()“ a inicializujeme „n1“ s hodnotou „44“. Pod tím je „int& n2“ inicializováno „returnTheValue(n1)“. Nyní vytiskneme hodnotu „n1“ a také jeho adresu. Poté vytiskneme hodnotu „n2“ a také adresu „n2“ pomocí „cout“.



Kód 1:



#include
pomocí jmenného prostoru std;
int & returnTheValue ( int & hodnota )
{
cout << 'Hodnota =' << hodnota << endl
<< 'Adresa hodnoty je'
<< & hodnota << endl;
vrátit se hodnota;
}
int main ( )
{
ty n1 = 44 ;
int & n2 = returnTheValue ( n1 ) ;
cout << 'n1 = ' << n1 << endl
<< 'Adresa n1 je'
<< & n1 << endl;
cout << 'n2 = ' << n2 << endl
<< 'Adresa n2 je'
<< & n2 << endl;
vrátit se 0 ;
}


Výstup:





Zde můžeme poznamenat, že odkaz je pouze alternativním názvem jiné proměnné, jak je uvedeno níže. Jako adresa hodnoty se „n1“ a „n2“ nikdy nemění.



Příklad 2:

Po importu hlavičkového souboru „iostream“ použijeme jmenný prostor „std“. Dále použijeme název funkce „MyReturnValueFunc“ a symbol „&“ k vytvoření funkce návratové reference. Zde je umístěn odkaz na proměnnou „v1“. Vytiskneme hodnotu a adresu s odkazem „&v1“ pod tím. Dále vložíme „referenční odkaz pro vrácení“ pomocí „return“ a „v1“ do tohoto umístění. Zde se zavolá „main()“ a „num_1“ se inicializuje hodnotou „19“. Inicializace „int& num_2“ se provádí pomocí „MyReturnValueFunc(num_1)“.

V současné době tiskneme hodnotu a adresu „num_1“ a pomocí „cout“ tiskneme hodnotu a adresu „num_2“. Nyní změníme hodnotu „num_1“ pomocí adresy, kterou sem vrací „MyReturnValueFunc“. Tato funkce vrací alternativní název „v1“, což je také alternativní název „num_1“. Změníme tedy jeho hodnotu a nastavíme ji na „91“. „91“ přiřadíme „MyReturnValueFunc(num_1)“, který zde funguje jako alias. Poté znovu vytiskneme hodnotu a adresu „num_1“.

Kód 2:

#include
pomocí jmenného prostoru std;
int & MyReturnValueFunc ( int & v1 )
{
cout << 'Hodnota v1 = ' << v1 << endl
<< 'Adresa proměnné v1 je'
<< & v1 << endl;
vrátit se v1;
}
int main ( )
{
int číslo_1 = 19 ;
int & num_2 = MyReturnValueFunc ( číslo_1 ) ;
cout << 'Hodnota num_1 = ' << číslo_1 << endl
<< 'Adresa num_1 je'
<< & číslo_1 << endl;
cout << 'Hodnota num_2 = ' << číslo_2 << endl
<< 'Adresa num_2 je'
<< & číslo_2 << endl;
MyReturnValueFunc ( číslo_1 ) = 91 ;
cout << 'Nyní, hodnota num_1 = ' << číslo_1 << endl
<< 'Adresa num_1 je'
<< & číslo_1 << endl;
vrátit se 0 ;
}


Výstup:

Jak je ukázáno v následujícím, můžeme vidět, že odkaz je pouze alternativním názvem pro jinou proměnnou, protože adresa hodnot „v1“, „num_1“ a „num_2“ zůstala konstantní:

Příklad 3:

Importuje se soubor záhlaví „iostream“ a použije se jmenný prostor „std“. Protože je v hlavičkových souborech uvedeno mnoho funkcí, importujeme je do kódů C++. Zde vytvoříme funkci „ReturnRefFun()“, do které umístíme „int& my_ref“, která vrátí odkaz. Jako referenční funkce je zde deklarována funkce „int& ReturnRefFun“. Poté zvýšíme hodnotu proměnné „my_ref“. Pod to vložíme „return“, který vrátí odkaz „my_ref“.

Poté se zde vyvolá metoda „main()“. Poté inicializujeme proměnnou „first_value“ s hodnotou „21“. Pod to vrátíme kopii reference umístěním „first_value“ do funkce „ReturnRefFun“ a uložíme ji do proměnné „copied_value“. Poté vytiskneme „first_value“ i „copied_value“ pomocí „cout“. Pod tím zvýšíme proměnnou „copied_value“ umístěním „copied_value++“. Poté vytiskneme „copied_value“ po jejím zvýšení a „first_value“ pomocí „cout“. Poté vrátíme referenci pomocí inicializace proměnné „int& ref_value“ pomocí „ReturnRefFun(first_value)“.

Poté vytiskneme hodnotu proměnné „my_ref“, kterou jsme zkopírovali. Poté vypíšeme hodnotu proměnné „first_value“. Pod tím zvýšíme hodnotu „ref_value“ vložením „ref_value++“. Pod tím vytiskneme inkrementovanou hodnotu „ref_value“ a také proměnnou „first_value“ pomocí „cout“. Když se změní „ref_value“, změní se také „first_value“.

Kód 3:

#include
pomocí jmenného prostoru std;
int & ReturnRefFun ( int & můj_ref ) {
můj_ref++;
vrátit se můj_ref;
}
int main ( ) {
int první_hodnota = dvacet jedna ;
int zkopírovaná_hodnota =ReturnRefFun ( první_hodnota ) ;
cout << 'První hodnota je:' << první_hodnota << endl;
cout << 'Zkopírovaná hodnota je:' << zkopírovaná_hodnota << endl;
zkopírovaná_hodnota++;
cout << 'Copied_value je zvýšena: ' << zkopírovaná_hodnota << endl;
cout << 'První hodnota:' << první_hodnota << endl;
int & referenční_hodnota =ReturnRefFun ( první_hodnota ) ;
cout << 'Referenční zkopírovaná hodnota: ' << referenční_hodnota << endl;
cout << 'První hodnota:' << první_hodnota << endl;
ref_value++;
cout << 'Referenční hodnota se zvýší: ' << referenční_hodnota << endl;
cout << 'První hodnota:' << první_hodnota << endl;
vrátit se 0 ;
}


Výstup:

Zde je výsledek předchozího kódu, kde jsme použili techniku ​​„návratové reference“. Příklad ukazuje rozdíl mezi vrácením duplikátu referenční proměnné a vrácením samotné referenční proměnné.

Příklad 4:

Zde je „int& rByRef“ deklarováno jako referenční funkce, která vrací referenční proměnnou. Této funkci „int& rByref()“ předáme „int& data“. Zde vytiskneme adresu proměnné „data“ a poté použijeme návratovou referenci pod touto. Nyní inicializujeme proměnnou „x_var“ po vyvolání metody „main()“. Poté zde vytiskneme adresu „x_var“ vložením „&x_var“ do pole „cout“.

Pod tím použijeme referenční proměnnou přiřazením „rByref(x_var)“ k „int& y_var“. Poté také vytiskneme adresu referenční proměnné „&y_var“. Pod tím zkopírujeme proměnnou „x_var“ do proměnné „z_var“ a také vypíšeme adresu této zkopírované proměnné, která je „&z_var“. Poté zavoláme funkci „rByref()“, předáme do ní proměnnou „x_var“ jako parametr a této proměnné přiřadíme „93“. Také znovu vykreslíme adresu „x_var“ vložením „&x_var“ do „cout“.

Kód 4:

#include
pomocí jmenného prostoru std;
int & rByref ( int & data )
{
cout << 'Adresa údajů: ' << & data << endl;
vrátit se data;
}
int main ( )
{
int x_var = 42 ;
cout << 'Adresa x_var: ' << & x_var << endl;
int & y_var = rByref ( x_var ) ;
cout << 'Adresa y_var: ' << & y_var << endl;
int z_var = rByref ( x_var ) ;
cout << 'Adresa z_var: ' << & z_var << endl;
rByref ( x_var ) = 93 ;
cout << 'Adresa x_var: ' << & x_var << endl;
vrátit se 0 ;
}


Výstup:

Výsledek jasně ukazuje, že adresa klonované proměnné „z_var“ se liší od všech ostatních umístění, na která původní proměnná „x_var“ odkazuje.

Závěr

Koncept „referenčního návratu“ je podrobně prozkoumán v tomto tutoriálu. Zjistili jsme, že „návratová reference“ je podobná „ukazatelům“ v programování v C++. Diskutovali jsme o tom, že k označení, která funkce vrací odkaz, je třeba použít symbol „&“ s návratovým typem funkce. V tomto tutoriálu jsme ilustrovali některé příklady a jejich výsledky a porozuměli tomuto konceptu.