In C++ puntatore e riferimento, entrambi vengono usati per accedere all'oggetto indirettamente. Quindi è importante sapere quando usare il puntatore e quando usare il riferimento. Questo articolo spiega la differenza tra puntatore e riferimento (puntatori e riferimenti) in C++. Qui, discuterò alcune importanti differenze tra il riferimento e il puntatore che ti aiutano a prendere la decisione quando usare il riferimento e quando usare il puntatore. Inoltre, utilizzerò alcuni frammenti di codice che ti aiutano a capire perché i riferimenti e i puntatori sono diversi tra loro.
Puoi anche vedere l'articolo menzionato di seguito,
- Riferimenti in C++, dovresti saperlo.
- Riferimento e cost in C++.
- Breve introduzione del puntatore.
- Differenza tra const reference e reference in un parametro.
Puntatori e riferimenti in C++:
Se abbiamo lasciato alcuni punti, i riferimenti sono simili ai puntatori. Di seguito ho selezionato alcuni punti che sono puntatori e riferimenti differenziati in C++ (puntatori vs riferimenti):
1. Dichiarazione e inizializzazione:
La struttura sintattica della dichiarazione di riferimento è simile alla dichiarazione del puntatore. La differenza è che mentre una dichiarazione di puntatore utilizza il * operatore, una dichiarazione di riferimento utilizza il & operatore. Significa il nome del puntatore seguito dal * (asterisco) ma il nome di riferimento seguito da & (Indirizzo dell'operatore).
Esempio,
//create an variable
int data = 6;
//rData (reference) refer to data
int& rData = data;
//pData (pointer) refer to data
int *pData = &data;
OR
int *pData;
pData = &data;
2. Inizializzazione con un puntatore NULL:
Un puntatore può puntare al puntatore null, ma un riferimento non può fare riferimento a NULL.
//reference refer to null int& rData = NULL; //error //pointer point to null int *pData = NULL; // ok
3. Rilegatura:
Dovresti ricordare che una volta che un riferimento si lega a qualsiasi oggetto, non si ricollegherà a un altro oggetto. Ma non è vero per i puntatori possiamo inizializzare i puntatori più volte secondo il requisito e non è necessario inizializzare i puntatori al momento della creazione.
/****reference****/ int& rData; //error int& rData = a; //ok, rData (reference) refer to 'a' rData = b; //error /****Pointer****/ int *pData; // ok int *pData = &a; // ok, pData point to 'a' pData = &b; // ok, pData point to 'b'
4. Modalità di accesso al valore:
Un riferimento può essere considerato come il nome di un oggetto. Quindi non abbiamo bisogno di alcun operatore aggiuntivo durante l'accesso al valore. Ma con i puntatori, abbiamo bisogno dell'operatore indiretto durante l'accesso al valore. Vediamo un codice di esempio per una migliore comprensione,
#include <iostream>
using namespace std;
int main()
{
//create an variable
int data = 6;
//pointer point to data
int *pData = &data;
//rOffData refer to data
int& rData = data;
cout << "Value of data, rData and pData" << endl;
cout << "data = " << data << endl;
//accessing value by reference
cout << "rData = " << rData << endl;
//accessing value by pointer
cout << "*pData = " << *pData << endl;
return 0;
}
Risultato:
Value of data, rData and pData data1 = 6 rData = 6 *pData = 6
Se vuoi imparare un linguaggio di programmazione online, puoi controllare i corsi, è disponibile una prova gratuita.
Fai clic per ottenere la tua prova gratuita
5. dynamic_cast fallito:
Un dynamic_cast fallito non ha lo stesso effetto su un puntatore e un riferimento:
1. Un dynamic_cast non riuscito su un puntatore restituisce un puntatore nullo.
2. Un dynamic_cast non riuscito su un riferimento genera un'eccezione di tipo std::bad_cast. Questo ha senso perché non può restituire un riferimento nullo.
6. Conservazione:
non è specificato se un riferimento richieda o meno la memorizzazione. Tuttavia, ho visto alcuni esempi in cui un riferimento condivide lo stesso indirizzo di memoria con la variabile originale ma occupa anche dello spazio nello stack. Vediamo un codice di esempio,
void fun(int& rChangeData)
{
rChangeData = 10;
}
int main()
{
int data = 5;
int& rData = data;
fun(rData);
return 0;
}
Nel codice precedente, rData non dovrebbe occupare spazio nello stack principale, ma il riferimento rChangeData della funzione prenderà posto nello stack. Significa che quando si chiama la funzione "fun" con rData come argomento, l'indirizzo dei dati verrà inserito nello stack di funzioni.
7. Sicurezza:
I riferimenti sono abbastanza più sicuri dei puntatori; è il motivo per cui la gente di C++ insiste a usare il riferimento nella programmazione C++. Ma dipende da te e dalle tue esigenze.
I puntatori sono più potenti dei riferimenti perché consentono il rebinding e l'annullamento dei valori. Anche se hai visto "Film Spider-Man" , allora sai che "un grande potere comporta grandi responsabilità", quindi devi sempre preoccuparti che un puntatore non sia nullo e non cambi il suo bersaglio appuntito.
Ma non è nemmeno vero al 100% che un riferimento è sempre sicuro, devi anche stare attento prima di utilizzare un riferimento.
Vediamo un esempio, in cui il riferimento non è valido e può causare comportamenti indefiniti e la cosa negativa è che sarebbe difficile rintracciare questo tipo di problema.
int* pData; int& rData = *pData;
Alcune altre differenze tra riferimenti e puntatori:
1. Non ci devono essere riferimenti a riferimenti ma puntatore a puntatore possibile.
2. Non ci devono essere array di riferimenti ma è possibile un array di puntatori.
3. Non devono esserci puntatori a riferimenti ma possibili puntatori a puntatori.
Post consigliato
- Corsi ed esercitazioni di programmazione C.
- Corsi ed esercitazioni sulla programmazione CPP.
- Corsi ed esercitazioni Python.
- Introduzione di riferimento in C++.
- Tutto sul nuovo operatore.
- MCQ C++ per te.
- Domande del colloquio C++ con risposte.
- costruttori in c++.
- Il miglior mouse per il programmatore.
- Elenco straordinario di regali per i programmatori, devi.
- I migliori kit elettronici per programmatori.
- Domande per l'intervista 100 C.
- Domande del colloquio C# con risposte.