Menu

Puntatori e operazioni con i puntatori in C ++

pointers pointer operations c

Prova Il Nostro Strumento Per Eliminare I Problemi

Uno studio approfondito dei puntatori e del loro utilizzo in C ++.

Un puntatore è una delle funzionalità più potenti del linguaggio C ++. Un puntatore aiuta a manipolare le variabili attraverso il suo indirizzo.

software installato su un computer e utilizzato per gestire le macchine virtuali

In questo tutorial, esploreremo in dettaglio tutto sui puntatori e sui loro usi in C ++.

=> Guarda qui la serie di formazione C ++ semplice.

Puntatori in c ++

Cosa imparerai:

Cos'è un puntatore?

Un puntatore è una variabile che contiene l'indirizzo di una posizione di memoria. Sappiamo che tutte le variabili che dichiariamo hanno un indirizzo specifico in memoria. Dichiariamo che una variabile puntatore punti a questi indirizzi in memoria.

La sintassi generale per dichiarare una variabile puntatore è:

datatype * variable_name;

Per esempio, la dichiarazione int * ptr;

Ciò significa che ptr è un puntatore che punta a una variabile di tipo int. Quindi una variabile puntatore contiene sempre una posizione o un indirizzo di memoria. Vediamo di seguito il funzionamento delle variabili puntatore.

Considera che abbiamo le seguenti dichiarazioni:

Int p, *ptr; //declare variable p and pointer variable ptr p = 4; //assign value 4 to variable p ptr = &p; //assign address of p to pointer variable ptr

In memoria, queste dichiarazioni saranno rappresentate come segue:

allocazione della memoria dei puntatori

Questa è la rappresentazione interna del puntatore in memoria. Quando assegniamo la variabile address alla variabile pointer, punta alla variabile come mostrato nella rappresentazione sopra.

Poiché ptr ha un indirizzo della variabile p, * ptr darà il valore della variabile p (variabile a cui punta la variabile puntatore ptr).

Nota: L'operatore * che usiamo con il puntatore viene utilizzato per indicare che si tratta di una variabile del puntatore.

Vediamo alcuni dei concetti di puntatore utilizzati in C ++.

Puntatore aritmetico

Sappiamo che una variabile puntatore punta sempre all'indirizzo in memoria. Tra le operazioni che possiamo eseguire, abbiamo le seguenti operazioni aritmetiche che vengono eseguite sui puntatori.

  • Operatore di incremento (++)
  • Operatore di decremento (-)
  • Addizione (+)
  • Sottrazione (-)

Vediamo l'utilizzo di queste operazioni in un programma di esempio.

#include #include using namespace std; int main() { int myarray(5) = {2, 4,6, 8,10}; int* myptr; myptr = myarray; cout<<'First element in the array :'<<*myptr<

Produzione:

Primo elemento dell'array: 2
elemento successivo nella matrice: 4
elemento successivo nella matrice: 6
elemento successivo nella matrice: 4
elemento successivo nella matrice: 2

Abbiamo visto le operazioni aritmetiche eseguite sui puntatori. Notare che l'operatore di incremento ++ incrementa il puntatore e punta all'elemento successivo dell'array. Allo stesso modo, l'operatore di decremento decrementa la variabile del puntatore di 1 in modo che punti all'elemento precedente nella matrice.

Usiamo anche gli operatori + e -. Per prima cosa, abbiamo aggiunto 1 alla variabile pointer. Il risultato mostra che punta all'elemento successivo dell'array. Allo stesso modo, l'operatore - fa in modo che la variabile del puntatore punti all'elemento precedente nell'array.

come aprire i file jar con java windows 10

Oltre a questi operatori aritmetici, possiamo anche utilizzare operatori di confronto come ==,.

Puntatori Null e Void

Se nel caso, a una variabile puntatore non viene assegnato un indirizzo di una variabile, è buona norma assegnare un valore NULL alla variabile puntatore. La variabile puntatore con un valore NULL è chiamata puntatore NULL.

Un puntatore nullo è un puntatore costante con valore zero definito nell'intestazione iostream. La memoria all'indirizzo 0 è riservata dal sistema operativo e non possiamo accedere a questa posizione.

Usando il puntatore nullo, possiamo evitare l'uso improprio di puntatori inutilizzati e impedire che alle variabili del puntatore siano assegnati alcuni valori inutili.

I puntatori vuoti sono i puntatori speciali che puntano ai valori senza tipo. I puntatori void sono più flessibili in quanto possono puntare a qualsiasi tipo. Ma non è possibile dereferenziarli direttamente. Per la dereferenziazione, il puntatore void deve essere convertito in un puntatore che punta a un valore con il tipo di dati concreto.

Abbiamo mostrato il funzionamento del puntatore NULL e del puntatore void nel seguente esempio di codice.

#include #include using namespace std; int main() { int intvar = 10; char c = 'A'; void* vptr; int* myptr = NULL; cout<<'NULL pointer value :'<

Produzione:

Valore del puntatore NULL: 0
Il puntatore Void vptr punta a: A
Il puntatore Void vptr punta a: 10

Nel programma precedente, per prima cosa dichiariamo un puntatore intero a cui è assegnato un valore NULL. Quando stampiamo questo puntatore, vediamo che il valore è 0 come abbiamo discusso in precedenza.

Successivamente, dichiariamo un puntatore void. Per prima cosa, assegniamo un indirizzo di variabile carattere a questo puntatore vuoto. Quindi assegniamo un puntatore void a un puntatore a carattere e lo tipizziamo con char *. Successivamente, stampiamo il valore charptr che punta a char A che era una variabile carattere che abbiamo dichiarato in precedenza ed è puntata dal puntatore void.

Successivamente, abbiamo assegnato una variabile intera al puntatore void e quindi eseguiamo gli stessi passaggi di dereferenziare questo puntatore void utilizzando un puntatore intero.

Matrici e puntatori

Matrici e puntatori sono fortemente associati tra loro. Sappiamo che il nome dell'array punta al primo elemento dell'array e questo è un puntatore costante.

Possiamo assegnare questo puntatore a una variabile del puntatore e quindi accedere all'array decrementando il puntatore o utilizzando l'operatore pedice.

Vedremo questa associazione tra la variabile del puntatore e l'array nel seguente esempio di codice.

#include #include using namespace std; int main() { int myarray(5) = {1, 1, 2, 3, 5}; int* ptrvar; ptrvar = myarray; for(int i=0;i<5;i++) { cout<<*ptrvar<<' '; ptrvar++; } return 0; }

Produzione:

1 1 2 3 5

Nel programma sopra, assegniamo il nome dell'array a una variabile del puntatore. Poiché il nome dell'array punta al primo elemento dell'array, possiamo stampare il contenuto dell'intero array utilizzando una variabile puntatore e incrementarlo utilizzando l'operatore ++. Questo è mostrato nell'output.

Matrice di puntatori

A volte, abbiamo bisogno di più di una variabile puntatore in un programma. Invece di dichiarare ogni singola variabile del puntatore, possiamo dichiarare un array di puntatori.

Facciamo subito un esempio per dimostrare un array di puntatori.

#include #include using namespace std; int main() { int myarray(5) = {2,4,6,8,10}; int *ptr(5); //array of pointers for(int i=0;i<5;i++){ ptr(i) = &myarray(i); } for (int i = 0; i < 5; i++) { cout << 'Value of myarray(' << i << ') = '; cout << *ptr(i) << endl; } return 0; }

Produzione:

Valore di myarray (0) = 2
Valore di myarray (1) = 4
Valore di myarray (2) = 6
Valore di myarray (3) = 8
Valore di myarray (4) = 10

Nella dichiarazione di cui sopra,

int * ptr (5);

Possiamo interpretare come; ptr è un array di 5 puntatori interi. Quindi ogni elemento di ptr punterà a una variabile di tipo integer.

Facciamo uso di un array intero e assegniamo l'indirizzo di ogni elemento dell'array a ciascuno degli elementi ptr. Quindi visualizziamo il contenuto dell'array ptr emettendo '* ptr (i)'.

Puntatore Di Puntatori

Il puntatore dei puntatori non è altro che più riferimenti indiretti. È una specie di catena di indicatori. Quando definiamo un puntatore di puntatori, il primo puntatore ha un indirizzo del secondo puntatore, che a sua volta ha l'indirizzo della variabile a cui punta.

In memoria, questo sarà rappresentato come:

Pointer of Pointers Allocazione di memoria

Un puntatore di puntatori viene dichiarato come segue:

int** intptr;

Prendiamo direttamente un esempio di codice per comprendere meglio il puntatore dei puntatori.

#include #include using namespace std; int main() { int *vptr; int ** intptr; int var = 10; vptr = &var; intptr = &vptr; cout<<'Variable var: '<

Produzione:

Var variabile: 10
Puntatore alla variabile: 10
Puntatore a Puntatore a una variabile: 10

Nel programma sopra, dichiariamo una variabile intera, un puntatore intero e un puntatore di un puntatore a un numero intero. Come mostrato nel programma, alla variabile pointer viene assegnato il valore di una variabile. Al puntatore della variabile puntatore viene assegnato l'indirizzo della variabile puntatore.

Alla fine, stampiamo le tre variabili che visualizzano lo stesso valore 10 uguale a una variabile intera.

Passaggio di puntatori alle funzioni

Il passaggio di puntatori alla funzione è lo stesso di altre tecniche di passaggio di parametri in cui si passano le variabili del puntatore alla funzione.

Rivisitiamo il nostro scambio di due valori e lo modifichiamo per passare le variabili del puntatore come parametri.

#include #include using namespace std; void swap(int* a, int* b) { int temp; temp = *a; *a = *b; *b = temp; } int main() { int a, b; cout<>a>>b; cout<<'a = '<

Puntatori di funzione

allo stesso modo, poiché abbiamo puntatori a variabili, array, ecc., possiamo anche avere puntatori a funzioni. Ma la differenza è che il puntatore a funzione punta al codice eseguibile e non a dati come variabili o array.

Prendiamo un esempio per dimostrare i puntatori a funzione.

#include #include using namespace std; void displayVal(int a) { printf('Value of a is %d ', a); } int main() { void (*func_ptr)(int) = &displayVal; (*func_ptr)(100); return 0; }

Produzione:

Il valore di a è 100

differenza tra attesa implicita ed esplicita nel selenio

Nel programma sopra, abbiamo una funzione 'displayVal' che stampa semplicemente un valore intero passato ad essa. Nella funzione principale, abbiamo definito un puntatore a funzione 'func_ptr' che accetta un int come argomento e restituisce un tipo void.

void (* func_ptr) (int)

Nota: Dobbiamo racchiudere il puntatore a funzione all'interno di (). Se lo omettiamo, diventerà un prototipo di funzione.

Abbiamo assegnato l'indirizzo della funzione 'displayVal' a questo puntatore di funzione. Quindi, utilizzando questo puntatore a funzione 'func_ptr', passiamo il valore dell'argomento 100 che equivale a chiamare displayVal con argomento 100.

Ora, se abbiamo un'altra funzione con lo stesso prototipo, possiamo usare lo stesso puntatore di funzione assegnandogli l'indirizzo della funzione. Questo è l'uso principale dei puntatori a funzione.

Conclusione

Riguarda i puntatori, le sue definizioni e gli usi in C ++.

Nel nostro prossimo tutorial, impareremo di più sui riferimenti in C ++. I riferimenti hanno anche un uso speciale in C ++ e sono spesso usati come alias per le variabili.

=> Fare clic qui per la serie di formazione Absolute C ++.

Lettura consigliata

^