Tutorial di programmazione C su Linux Parte 20 - Aritmetica degli indirizzi dei puntatori

Nel nostro tutorial precedente di questa serie di programmazione C, abbiamo discusso i puntatori in un po’ di dettaglio. Estendendo quella discussione, eccoci con alcuni concetti meritevoli di discussione relativi ai puntatori. Quindi, senza ulteriori indugi, iniziamo.

Aritmetica degli indirizzi dei puntatori in C

Innanzitutto, concentriamoci sull’aritmetica degli indirizzi quando si tratta di puntatori. Come abbiamo discusso nel nostro tutorial precedente, se hai un puntatore che punta a un array (diciamo l’inizio di esso), è molto facile accedere agli elementi di quell’array. Ecco un esempio:

#include   
  
int main()  
{  
    char arr[]={'a','b','c','d'};  
    int a[]={1,2,3,4};  
   
    char *ptr = arr;  
    int *p = a;  
   
    for(int i=0; i

Quindi in questo codice, abbiamo due array - ‘arr’ e ‘a’. Mentre il primo è un array di caratteri, il secondo è un array di interi. Poi abbiamo due puntatori che puntano a questi array - ‘ptr’ e ‘p’, rispettivamente. Poi ci sono un paio di cicli ‘for’ in cui stampiamo l’indirizzo attuale a cui il puntatore sta puntando e il valore contenuto a quell’indirizzo.

Ecco l’output di questo codice sulla mia macchina:

 Puntatore carattere che punta a 726409312, con valore a   
 Puntatore carattere che punta a 726409313, con valore b   
 Puntatore carattere che punta a 726409314, con valore c   
 Puntatore carattere che punta a 726409315, con valore d   
 Puntatore intero che punta a 726409296, con valore 1   
 Puntatore intero che punta a 726409300, con valore 2   
 Puntatore intero che punta a 726409304, con valore 3   
 Puntatore intero che punta a 726409308, con valore 4

Ora, ciò che è degno di nota qui sono gli indirizzi stampati nell’output. Per l’array di caratteri, aggiungere ‘1’ al puntatore lo ha incrementato all’indirizzo immediatamente successivo, ma per un array di interi, aggiungere ‘1’ al puntatore lo ha fatto saltare 4 indirizzi avanti. Perché è così?

Bene, tutto dipende dal tipo di puntatore. Un puntatore a carattere salta sempre il numero di byte occupati da un carattere, che di solito è 1. Allo stesso modo, un puntatore a un intero di solito salta 4 byte quando viene incrementato di 1. Quindi questo dovrebbe spiegare la differenza nei salti dei puntatori a caratteri e interi nell’output sopra.

Proseguendo con l’aritmetica dei puntatori, i puntatori possono essere utilizzati in espressioni di confronto in casi selezionati. Ad esempio, se vuoi confermare se un puntatore ‘ptr’ punta a un elemento di un array ‘arr’ (dimensionato ‘size’), allora puoi fare il confronto nel seguente modo:

if((ptr >= arr) && (ptr < (arr + size))) 

Quindi, effettivamente, l’espressione sopra verifica se l’indirizzo detenuto dal puntatore è di uno dei suoi elementi.

Inoltre, se ci sono più puntatori che puntano a elementi dello stesso array, puoi utilizzare i seguenti operatori di confronto ==, !=, < e >=. Infatti, puoi anche eseguire la sottrazione dei puntatori in questi casi. Ecco un esempio:

#include   
  
int main()  
{  
    char arr[]= "Benvenuto su HowtoForge";  
   
    char *ptr = arr;  
    char *p = arr;  
   
    while(*p != '\0')  
   {  
      p++;  
   }  
   
   printf("\n La lunghezza della stringa è %d", (p - ptr));  
   
   return 0;  
}

Quindi in questo programma, ci siamo assicurati che un puntatore punti al primo elemento dell’array, mentre il secondo puntatore viene continuamente incrementato fino a puntare all’ultimo elemento (che è ‘\0’ nelle stringhe costanti).

Poi, dato che stiamo trattando caratteri qui (che occupano un byte ciascuno), sottraendo l’indirizzo puntato dal primo puntatore da quello puntato dal secondo puntatore, possiamo trovare il numero di caratteri, che se guardi è la lunghezza esatta della stringa.

NOTA: Tieni presente che operazioni come somma, moltiplicazione, divisione e altro sono invalide quando si tratta di puntatori. Inoltre, il tipo di operazioni accettabili che abbiamo elencato finora è valido solo quando i puntatori sono dello stesso tipo e puntano a elementi dello stesso array.

Conclusione

Dopo aver discusso i concetti di base dei puntatori nel tutorial precedente, abbiamo ampliato il concetto di puntatori discutendo l’aritmetica degli indirizzi dei puntatori qui. Ti suggeriamo di praticare ciò che abbiamo discusso qui sulla tua macchina sotto forma di programmi. E nel caso tu abbia qualche dubbio o domanda, non esitare a lasciare un commento qui sotto.