C++ fornisce la possibilità di restituire un valore o un indirizzo tramite il suo riferimento anziché tramite puntatori. L'uso dei riferimenti anziché dei puntatori può rendere un programma C++ più semplice da leggere e gestire. In C++, riferimenti e puntatori sono strettamente correlati tra loro. La distinzione principale è che sebbene i riferimenti siano semplicemente un nome alternativo, 'alias' per un'altra variabile, i puntatori possono essere utilizzati in operazioni come l'aggiunta di valori. Un riferimento è un nome alternativo o un duplicato del valore originale ed è indicato dal simbolo '&'.
Esempio 1:
Importiamo il file di intestazione 'iostream' e quindi utilizziamo lo spazio dei nomi 'std'. I file di intestazione vengono importati in codici C++ man mano che vengono definite molte funzioni. Quindi, creiamo una funzione di riferimento di ritorno inserendo il simbolo '&' con il nome della funzione, 'returnTheValue'.
Qui è ora inserito il riferimento al “valore”. Sotto stampiamo il valore e l'indirizzo con il riferimento '&value'. Quindi, inseriamo il riferimento al reso e inseriamo il “valore”. Ora, qui viene richiamato 'main()' e inizializziamo 'n1' con il valore '44'. Al di sotto di questo, 'int& n2' viene inizializzato con 'returnTheValue(n1)'. Ora stampiamo il valore di “n1” e il suo indirizzo. Quindi, stampiamo il valore di “n2” e l'indirizzo di “n2” utilizzando il “cout”.
Codice 1:
#include
utilizzando lo spazio dei nomi std;
int & returnTheValue ( int & valore )
{
cout << 'Valore = ' << valore << fine
<< ' L'indirizzo del valore è '
<< & valore << fine;
ritorno valore;
}
int principale ( )
{
tu n1 = 44 ;
int & n2 = restituisceIlValore ( n1 ) ;
cout << 'n1 = ' << n1 << fine
<< ' L'indirizzo di n1 è '
<< & n1 << fine;
cout << 'n2 = ' << n2 << fine
<< ' L'indirizzo di n2 è '
<< & n2 << fine;
ritorno 0 ;
}
Produzione:
Qui possiamo notare che un riferimento è solo un nome alternativo di un'altra variabile, come mostrato di seguito. Come indirizzo del valore, “n1” e “n2” non cambiano mai.
Esempio 2:
Utilizziamo lo spazio dei nomi 'std' dopo aver importato il file di intestazione 'iostream'. Successivamente, utilizziamo il nome della funzione 'MyReturnValueFunc' e il simbolo '&' per creare una funzione di riferimento di ritorno. Il riferimento alla variabile “v1” viene inserito qui. Stampiamo il valore e l'indirizzo con il riferimento '&v1' sotto. Successivamente, inseriamo il 'riferimento di ritorno' utilizzando 'return' e 'v1' in questa posizione. Qui viene chiamato 'main()' e 'num_1' viene inizializzato con il valore '19'. L'inizializzazione di 'int& num_2' viene eseguita con 'MyReturnValueFunc(num_1)'.
Attualmente stampiamo il valore e l'indirizzo di “num_1” e, utilizzando “cout”, stampiamo il valore e l'indirizzo di “num_2”. Ora modifichiamo il valore di 'num_1' utilizzando l'indirizzo restituito qui da 'MyReturnValueFunc'. Questa funzione restituisce il nome alternativo di 'v1' che è anche il nome alternativo di 'num_1'. Quindi, cambiamo il suo valore e lo impostiamo su “91”. Assegniamo '91' a 'MyReturnValueFunc(num_1)' che qui funge da alias. Quindi stampiamo nuovamente il valore e l'indirizzo di “num_1”.
Codice 2:
#includeutilizzando lo spazio dei nomi std;
int & MyReturnValueFunc ( int & v1 )
{
cout << 'Il valore di v1 = ' << v1 << fine
<< ' L'indirizzo della variabile v1 è '
<< & v1 << fine;
ritorno v1;
}
int principale ( )
{
int num_1 = 19 ;
int & num_2 = MyReturnValueFunc ( numero_1 ) ;
cout << 'Il valore di num_1 = ' << numero_1 << fine
<< ' L'indirizzo di num_1 è '
<< & numero_1 << fine;
cout << 'Il valore di num_2 = ' << numero_2 << fine
<< ' L'indirizzo di num_2 è '
<< & numero_2 << fine;
MyReturnValueFunc ( numero_1 ) = 91 ;
cout << 'Ora, il valore di num_1 = ' << numero_1 << fine
<< 'L'indirizzo di num_1 è '
<< & numero_1 << fine;
ritorno 0 ;
}
Produzione:
Come dimostrato di seguito, possiamo vedere che un riferimento è semplicemente un nome alternativo per un'altra variabile poiché l'indirizzo dei valori 'v1', 'num_1' e 'num_2' è rimasto costante:
Esempio 3:
Viene importato il file di intestazione 'iostream' e viene utilizzato lo spazio dei nomi 'std'. Poiché nei file header sono specificate numerose funzioni, le importiamo nei codici C++. Qui creiamo una funzione “ReturnRefFun()” in cui inseriamo “int& my_ref” che restituisce il riferimento. Qui viene dichiarato 'int& ReturnRefFun' come funzione di riferimento. Successivamente, incrementiamo il valore della variabile “my_ref”. Sotto questo inseriamo “return” che restituisce il riferimento di “my_ref”.
Successivamente, qui viene richiamato il metodo “main()”. Quindi, inizializziamo la variabile “first_value” con “21”. Al di sotto di questo, restituiamo la copia del riferimento inserendo 'first_value' nella funzione 'ReturnRefFun' e salvandolo nella variabile 'copied_value'. Quindi, stampiamo sia il 'first_value' che il 'copied_value' utilizzando il 'cout'. Sotto questo, incrementiamo la variabile “copied_value” inserendo “copied_value++”. Quindi, stampiamo il 'copied_value' dopo averlo incrementato e il 'first_value' utilizzando 'cout'. Successivamente, restituiamo il riferimento con l'aiuto dell'inizializzazione della variabile 'int& ref_value' con 'ReturnRefFun(first_value)'.
Successivamente, stampiamo il valore della variabile “my_ref” che abbiamo copiato. Quindi, stampiamo il valore della variabile “first_value”. Sotto questo, incrementiamo il valore di “ref_value” inserendo “ref_value++”. Sotto stampiamo il valore incrementato di “ref_value” e anche la variabile “first_value” con l'aiuto di “cout”. Quando il 'ref_value' viene modificato, cambierà anche il 'first_value'.
Codice 3:
#includeutilizzando lo spazio dei nomi std;
int & RitornoRefFun ( int & mio_rif ) {
mio_rif++;
ritorno mio_rif;
}
int principale ( ) {
int primo_valore = ventuno ;
int valore_copiato =RitornoRifFun ( primo_valore ) ;
cout << 'Il primo valore è: ' << primo_valore << fine;
cout << 'Il valore copiato è: ' << valore_copiato << fine;
valore_copiato++;
cout << 'Il valore_copiato viene incrementato: ' << valore_copiato << fine;
cout << 'Il primo valore: ' << primo_valore << fine;
int & valore_rif =RitornoRifFun ( primo_valore ) ;
cout << 'Il valore copiato di riferimento: ' << valore_rif << fine;
cout << 'Il primo valore: ' << primo_valore << fine;
valore_rif++;
cout << 'Il valore di riferimento viene incrementato: ' << valore_rif << fine;
cout << 'Il primo valore: ' << primo_valore << fine;
ritorno 0 ;
}
Produzione:
Ecco il risultato del codice precedente in cui abbiamo utilizzato la tecnica del 'riferimento di ritorno'. L'esempio mostra la distinzione tra restituire un duplicato della variabile di riferimento e restituire la variabile di riferimento stessa.
Esempio 4:
Qui, 'int& rByRef' è dichiarato come funzione di riferimento che restituisce la variabile di riferimento. Passiamo 'int& data' a questa funzione 'int& rByref()'. Qui stampiamo l'indirizzo della variabile 'data' e quindi utilizziamo il riferimento di ritorno sotto questo. Ora inizializziamo la variabile “x_var” dopo aver invocato il metodo “main()”. Quindi, stampiamo qui l'indirizzo di 'x_var' inserendo '&x_var' nel 'cout'.
Al di sotto di questo, utilizziamo la variabile di riferimento assegnando 'rByref(x_var)' a 'int& y_var'. Quindi, stampiamo anche l'indirizzo della variabile di riferimento “&y_var”. Sotto questo, copiamo la variabile “x_var” nella variabile “z_var” e stampiamo anche l'indirizzo di questa variabile copiata che è “&z_var”. Successivamente, chiamiamo la funzione “rByref()”, passiamo la variabile “x_var” come parametro al suo interno e assegniamo “93” a questa variabile. Inoltre rendiamo nuovamente l'indirizzo di “x_var” inserendo “&x_var” in “cout”.
Codice 4:
#includeutilizzando lo spazio dei nomi std;
int & rByref ( int & dati )
{
cout << 'Indirizzo dei dati: ' << & dati << fine;
ritorno dati;
}
int principale ( )
{
int x_var = 42 ;
cout << 'Indirizzo di x_var: ' << & x_var << fine;
int & y_var = rByref ( x_var ) ;
cout << 'Indirizzo di y_var: ' << & y_var << fine;
int z_var = rByref ( x_var ) ;
cout << 'Indirizzo di z_var: ' << & z_var << fine;
rByref ( x_var ) = 93 ;
cout << 'Indirizzo di x_var: ' << & x_var << fine;
ritorno 0 ;
}
Produzione:
Il risultato chiarisce che l’indirizzo della variabile clonata, “z_var”, differisce da tutte le altre posizioni a cui fa riferimento la variabile originale, “x_var”.
Conclusione
Il concetto di 'riferimento di ritorno' viene esplorato in dettaglio in questo tutorial. Abbiamo appreso che il 'riferimento di ritorno' è simile ai 'puntatori' nella programmazione C++. Abbiamo discusso del fatto che per indicare quale funzione restituisce un riferimento, è necessario utilizzare il simbolo '&' con il tipo restituito dalla funzione. Abbiamo illustrato alcuni esempi e i loro risultati e abbiamo compreso questo concetto in questo tutorial.