Puntatori nella programmazione C: cos'è puntatore, tipi e amp; Esempi

Cos'è il puntatore in C?

Il puntatore in C è una variabile che memorizza l'indirizzo di un'altra variabile. Un puntatore può essere utilizzato anche per fare riferimento a un'altra funzione del puntatore. Un puntatore può essere incrementato / decrementato, cioè per puntare alla posizione di memoria successiva / precedente. Lo scopo del puntatore è quello di risparmiare spazio in memoria e ottenere tempi di esecuzione più rapidi.

Come usare i puntatori in C

Se dichiariamo una variabile v di tipo int, v memorizzerà effettivamente un valore.

v è uguale a zero ora.

Tuttavia, ogni variabile, oltre al valore, ha anche il suo indirizzo (o, semplicemente, dove si trova nella memoria). L'indirizzo può essere recuperato inserendo una e commerciale (&) prima del nome della variabile.

Se stampi l'indirizzo di una variabile sullo schermo, apparirà come un numero totalmente casuale (inoltre, può essere diverso da run a run).

Proviamo questo in pratica con il puntatore nell'esempio C.

L'output di questo programma è -480613588.

Cos'è un puntatore? Invece di memorizzare un valore, un puntatore y memorizzerà l'indirizzo di una variabile.

Variabile puntatore

Int * y = & v;

VARIABILE	PUNTATORE
Un valore archiviato in un indirizzo di archiviazione / memoria denominato	Una variabile che punta all'indirizzo di archiviazione / memoria di un'altra variabile

Dichiarazione di un puntatore

Come le variabili, i puntatori nella programmazione C devono essere dichiarati prima di poter essere utilizzati nel programma. I puntatori possono essere denominati come si desidera purché obbediscano alle regole di denominazione di C. Una dichiarazione di puntatore ha la seguente forma.

data_type * pointer_variable_name;

Qui,

• data_type è il tipo di base del puntatore dei tipi di variabile di C e indica il tipo di variabile a cui punta il puntatore.
• L'asterisco (*: lo stesso asterisco usato per la moltiplicazione) che è un operatore di riferimento indiretto, dichiara un puntatore.

Vediamo alcune dichiarazioni di puntatori valide in questo tutorial sui puntatori C:

int *ptr_thing; /* pointer to an integer */int *ptr1,thing;/* ptr1 is a pointer to type integer and thing is an integer variable */double *ptr2; /* pointer to a double */float *ptr3; /* pointer to a float */char *ch1 ; /* pointer to a character */float *ptr, variable;/*ptr is a pointer to type float and variable is an ordinary float variable */

Inizializza un puntatore

Dopo aver dichiarato un puntatore, lo inizializziamo come variabili standard con un indirizzo variabile. Se i puntatori nella programmazione C non vengono inizializzati e utilizzati nel programma, i risultati sono imprevedibili e potenzialmente disastrosi.

Per ottenere l'indirizzo di una variabile, utilizziamo l'operatore e commerciale (&), posto prima del nome di una variabile di cui abbiamo bisogno l'indirizzo. L'inizializzazione del puntatore viene eseguita con la seguente sintassi.

Sintassi del puntatore

 pointer = &variable; 

Di seguito viene fornito un semplice programma per l'illustrazione del puntatore:

#include int main(){int a=10; //variable declarationint *p; //pointer variable declarationp=&a; //store address of variable a in pointer pprintf("Address stored in a variable p is:%x\n",p); //accessing the addressprintf("Value stored in a variable p is:%d\n",*p); //accessing the valuereturn 0;}

Produzione:

Address stored in a variable p is:60ff08Value stored in a variable p is:10

Operatore	Significato
*	Serve 2 scopi Dichiarazione di un puntatore Restituisce il valore della variabile di riferimento
&	Serve solo 1 scopo Restituisce l'indirizzo di una variabile

Tipi di puntatori in C

Di seguito sono riportati i diversi tipi di puntatori in C :

Puntatore nullo

Possiamo creare un puntatore nullo assegnando un valore nullo durante la dichiarazione del puntatore. Questo metodo è utile quando non si dispone di alcun indirizzo assegnato al puntatore. Un puntatore nullo contiene sempre il valore 0.

Il seguente programma illustra l'uso di un puntatore nullo:

#include int main(){int *p = NULL; //null pointerprintf(“The value inside variable p is:\n%x”,p);return 0;}

Produzione:

The value inside variable p is:0

Puntatore vuoto

Nella programmazione C, un puntatore void viene anche chiamato come puntatore generico. Non ha alcun tipo di dati standard. Un puntatore void viene creato utilizzando la parola chiave void. Può essere utilizzato per memorizzare un indirizzo di qualsiasi variabile.

Il seguente programma illustra l'uso di un puntatore vuoto:

#include int main(){void *p = NULL; //void pointerprintf("The size of pointer is:%d\n",sizeof(p));return 0;}

Produzione:

The size of pointer is:4

Puntatore selvaggio

Si dice che un puntatore sia un puntatore jolly se non viene inizializzato a nulla. Questi tipi di puntatori C non sono efficienti perché potrebbero puntare a una posizione di memoria sconosciuta che potrebbe causare problemi nel nostro programma e potrebbe portare al blocco del programma. Si dovrebbe sempre stare attenti quando si lavora con i puntatori selvaggi.

Il seguente programma illustra l'uso del puntatore jolly:

#include int main(){int *p; //wild pointerprintf("\n%d",*p);return 0;}

Produzione

timeout: the monitored command dumped coresh: line 1: 95298 Segmentation fault timeout 10s main

Altri tipi di puntatori in "c" sono i seguenti:

• Puntatore penzoloni
• Puntatore complesso
• Vicino al puntatore
• Puntatore lontano
• Puntatore enorme

Puntatori di accesso diretto e indiretto

In C, ci sono due modi equivalenti per accedere e manipolare un contenuto variabile

• Accesso diretto: usiamo direttamente il nome della variabile
• Accesso indiretto: utilizziamo un puntatore alla variabile

Capiamo questo con l'aiuto del programma di seguito

#include /* Declare and initialize an int variable */int var = 1;/* Declare a pointer to int */int *ptr;int main( void ){/* Initialize ptr to point to var */ptr = &var;/* Access var directly and indirectly */printf("\nDirect access, var = %d", var);printf("\nIndirect access, var = %d", *ptr);/* Display the address of var two ways */printf("\n\nThe address of var = %d", &var);printf("\nThe address of var = %d\n", ptr);/*change the content of var through the pointer*/*ptr=48;printf("\nIndirect access, var = %d", *ptr);return 0;}

Dopo aver compilato il programma senza errori, il risultato è:

Direct access, var = 1Indirect access, var = 1The address of var = 4202496The address of var = 4202496Indirect access, var = 48

Aritmetica dei puntatori in C

Le operazioni del puntatore sono riassunte nella figura seguente

Operazione prioritaria (precedenza)

Quando si lavora con i puntatori C, dobbiamo osservare le seguenti regole di priorità:

• Gli operatori * e & hanno la stessa priorità degli operatori unari (la negazione !, l'incremento ++, il decremento--).
• Nella stessa espressione, gli operatori unari *, &,!, ++, - vengono valutati da destra a sinistra.

Se un puntatore P punta a una variabile X, allora * P può essere usato ovunque sia possibile scrivere X.

Le seguenti espressioni sono equivalenti:

int X = 10 int * P = & Y; Per il codice precedente, le espressioni seguenti sono vere
Espressione	Espressione equivalente
Y = * P + 1 * P = * P + 10 * P + = 2 ++ * P (* P) ​​++	Y = X + 1 X = X + 10 X + = 2 ++ X X ++

In quest'ultimo caso sono necessarie le parentesi: poiché gli operatori unari * e ++ sono valutati da destra a sinistra, senza le parentesi verrebbe incrementato il puntatore P, non l'oggetto su cui punta P.

La tabella seguente mostra le operazioni aritmetiche e di base che possono essere utilizzate quando si ha a che fare con i puntatori C.

Operazione	Spiegazione
Incarico	int * P1, * P2 P1 = P2; P1 e P2 puntano alla stessa variabile intera
Incremento e decremento	Int * P1; P1 ++; P1--;
Aggiunta di un offset (costante)	Ciò consente al puntatore di spostare N elementi in una tabella. Il puntatore verrà aumentato o diminuito di N volte il numero di byte del tipo di variabile. P1 + 5;

C Puntatori e matrici con esempi

Tradizionalmente, si accede agli elementi dell'array usando il suo indice, ma questo metodo può essere eliminato usando i puntatori. I puntatori facilitano l'accesso a ogni elemento dell'array.

#include int main(){int a[5]={1,2,3,4,5}; //array initializationint *p; //pointer declaration/*the ptr points to the first element of the array*/p=a; /*We can also type simply ptr==&a[0] */printf("Printing the array elements using pointer\n");for(int i=0;i<5;i++) //loop for traversing array elements{printf("\n%x",*p); //printing array elementsp++; //incrementing to the next element, you can also write p=p+1}return 0;}

Produzione

12345

L'aggiunta di un numero particolare a un puntatore sposterà la posizione del puntatore sul valore ottenuto da un'operazione di addizione. Supponiamo che p sia un puntatore che attualmente punta alla posizione di memoria 0 se eseguiamo la seguente operazione di addizione, p + 1, verrà eseguita in questo modo:

Poiché p attualmente punta alla posizione 0 dopo aver aggiunto 1, il valore diventerà 1, e quindi il puntatore punterà alla posizione di memoria 1.

Puntatori e stringhe in C con esempi

Una stringa è un array di oggetti char, che termina con un carattere null "\ 0". Possiamo manipolare le stringhe usando i puntatori. Questo puntatore nell'esempio C spiega questa sezione

#include #include int main(){char str[]="Hello Guru99!";char *p;p=str;printf("First character is:%c\n",*p);p =p+1;printf("Next character is:%c\n",*p);printf("Printing all the characters in a string\n");p=str; //reset the pointerfor(int i=0;i
Produzione
First character is:HNext character is:ePrinting all the characters in a stringHelloGuru99!
Un altro modo per gestire le stringhe è con un array di puntatori come nel seguente programma:
#include int main(){char *materials[ ] = { "iron", "copper", "gold"};printf("Please remember these materials :\n");int i ;for (i = 0; i < 3; i++) {printf("%s\n", materials[ i ]);}return 0;}
Produzione:
Please remember these materials:ironcoppergold
 
Vantaggi dei puntatori in C

I puntatori sono utili per accedere alle posizioni di memoria.
I puntatori forniscono un modo efficiente per accedere agli elementi di una struttura di array.
I puntatori vengono utilizzati per l'allocazione dinamica della memoria e per la deallocazione.
I puntatori vengono utilizzati per formare strutture di dati complesse come elenchi collegati, grafici, alberi, ecc.


Svantaggi dei puntatori in C

I puntatori sono un po 'complessi da capire.
I puntatori possono portare a vari errori come errori di segmentazione o possono accedere a una posizione di memoria che non è affatto richiesta.
Se un valore errato viene fornito a un puntatore, potrebbe causare il danneggiamento della memoria.
I puntatori sono anche responsabili della perdita di memoria.
I puntatori sono relativamente più lenti di quelli delle variabili.
I programmatori trovano molto difficile lavorare con i puntatori; pertanto è responsabilità del programmatore manipolare un puntatore con attenzione.

Sommario 

Un puntatore non è altro che una posizione di memoria in cui vengono memorizzati i dati.
Un puntatore viene utilizzato per accedere alla posizione di memoria.
Esistono vari tipi di puntatori come un puntatore nullo, un puntatore jolly, un puntatore vuoto e altri tipi di puntatori.
I puntatori possono essere utilizzati con array e stringhe per accedere agli elementi in modo più efficiente.
Possiamo creare puntatori a funzione per invocare dinamicamente una funzione.
Le operazioni aritmetiche possono essere eseguite su un puntatore noto come aritmetica del puntatore.
I puntatori possono anche puntare a una funzione che semplifica il richiamo di funzioni diverse nel caso di definizione di una matrice di puntatori.
Quando si desidera gestire diversi tipi di dati variabili, è possibile utilizzare un puntatore void typecast.