Sappiamo che la variabile puntatore può memorizzare l'indirizzo di memoria in linguaggio C e in questo articolo impareremo come utilizzare quel puntatore per accedere ai dati memorizzati nella posizione di memoria puntata dal puntatore.
Cos'è un puntatore?
Prima di tutto, rivediamo cos'è un puntatore. Un puntatore è una variabile che memorizza l'indirizzo di memoria di un'altra variabile. Il puntatore ci aiuta a manipolare i dati nell'indirizzo di memoria puntato dal puntatore. Inoltre, più puntatori possono puntare alla stessa memoria.
Considera il seguente esempio,
int num = 10; int *ptr; ptr = #>
Abbiamo memorizzato l'indirizzo del nessuno variabile nel ptr puntatore, ma ora come accedere al valore archiviato in memoria all'indirizzo puntato da ptr ? Qui entra in gioco il dereferenziamento.
Puntatore di dereferenziazione in C
L'accesso o la manipolazione del contenuto archiviato nell'indirizzo di memoria indicato dal puntatore utilizzando l'operatore di dereferenziazione o indiretto (*) è chiamato dereferenziazione del puntatore.
Puntatore di dereferenziazione in C
età del dharmendra
Sintassi per dereferenziare un puntatore
Usiamo l'operatore indiretto (*) come prefisso per dereferenziare un puntatore:
* ( pointer_name )>
Per modificare i dati archiviati nella memoria, utilizziamo
* ( pointer_name ) = new_value;>
È da notare che il new_value deve essere dello stesso tipo del precedente.
Considera gli esempi sopra dove ptr punta a se, t Il contenuto dell'indirizzo di memoria è accessibile all'operatore di dereferenziazione *. Ora *ptr recupererà il contenuto memorizzato nell'indirizzo che è 10.
L'indirizzo e i valori di memoria num e ptr appariranno così.
| Variabile | Indirizzo di memoria | Valore |
|---|---|---|
| numero = 10 | 202020 | 10 |
| 202021 | ||
| 202022 | ||
| 202023 | ||
| ptr = &num | 202024 – 202032 | 202020 |
Nota: Abbiamo presupposto che l'architettura nell'esempio precedente sia indirizzabile tramite byte, ovvero l'unità minima che ha un indirizzo separato è un byte.
Esempi di dereferenziazione dei puntatori
Esempio 1:
Utilizzo di un puntatore per accedere e modificare il valore di una variabile intera.
C
// C Program to illustrate the dereferencing of pointer> #include> int> main()> {> >// Declare integer variable number> >int> num = 10;> >// Declare pointer to store address of number> >int>* ptr = #> >// Print the value of number> >printf>(>'Value of num = %d
'>, num);> >// Print Address of the number using & operator> >printf>(>'Address of num = %d
'>, &num);> >// Print Address stored in the pointer> >printf>(>'Address stored in the ptr = %p
'>, ptr);> >printf>(>'Dereference content in ptr using *ptr
'>);> >// Access the content using * operator> >printf>(>'Value of *ptr = %d
'>, *ptr);> >printf>(>'Now, *ptr is same as number
'>);> >printf>(>'Modify the value using pointer to 6
'>);> >// Modify the content in the address to 6 using pointer> >*ptr = 6;> >// Print the modified value using pointer> >printf>(>'Value of *ptr = %d
'>, *ptr);> >// Print the modified value using variable> >printf>(>'Value of number = %d
'>, num);> >return> 0;> }> |
>
>
Produzione
Value of num = 10 Address of num = 0x7ffe47d51b4c Address stored in the ptr = 0x7ffe47d51b4c Dereference content in ptr using *ptr Value of *ptr = 10 Now, *ptr is same as number Modify the value using pointer to 6 Value of *ptr = 6 Value of number = 6>
Esempio 2: dereferenziazione di un doppio puntatore
È anche possibile dereferenziare i puntatori doppi utilizzando la stessa logica, ma sarà necessario utilizzare l'operatore indiretto due volte: una per spostarsi sul puntatore a cui punta il puntatore doppio e l'altra per accedere al valore effettivo.
C
// C program to dereference double pointer> #include> int> main()> {> >int> var = 10;> >int>* ptr = &var;> >// double pointer> >int>** dptr = &ptr;> >// dereferencing the double pointer> >printf>(>'Accesing value from double pointer using '> >'**dptr: %d'>,> >**dptr);> >return> 0;> }> |
>
>Produzione
Accesing value from double pointer using **dptr: 10>
Proprio così, possiamo dereferenziare puntatori di qualsiasi livello.
Come funziona il dereferenziamento?
Ogni volta che chiediamo al compilatore di dereferenziare un puntatore, fa tre cose:
- Per prima cosa cerca l'indirizzo memorizzato nel puntatore.
- Quindi cerca il tipo di puntatore in modo da poter dedurre la quantità di memoria da leggere. Ad esempio, 4 byte per int, 1 byte per char, ecc. È anche il motivo principale per cui dobbiamo specificare il tipo di puntatore nella dichiarazione anche se la dimensione di ogni puntatore in un sistema è la stessa.
- Infine, legge la memoria e restituisce i dati memorizzati.
Nota: Dal ragionamento sopra, possiamo anche dedurre che non possiamo dereferenziare il puntatore void poiché la dimensione dei dati a cui punta è sconosciuta. Quindi dobbiamo digitare il puntatore void per dereferenziarlo.