Puntatori C (con esempi)

In questo tutorial imparerai a conoscere i puntatori; cosa sono i puntatori, come li usi e gli errori comuni che potresti incontrare quando lavori con loro con l'aiuto di esempi.

I puntatori sono potenti funzionalità della programmazione C e C ++. Prima di apprendere i puntatori, impariamo gli indirizzi nella programmazione C.

Indirizzo in C

Se hai una variabile var nel tuo programma, &varti darà il suo indirizzo in memoria.

Abbiamo utilizzato l'indirizzo numerose volte durante l'utilizzo della scanf()funzione.

 scanf("%d", &var);

Qui, il valore inserito dall'utente è memorizzato nell'indirizzo della variabile var. Facciamo un esempio funzionante.

 #include int main() ( int var = 5; printf("var: %d", var); // Notice the use of & before var printf("address of var: %p", &var); return 0; )

Produzione

 var: 5 indirizzo di var: 2686778

Nota: probabilmente otterrai un indirizzo diverso quando esegui il codice sopra.

Puntatori C.

I puntatori (variabili puntatore) sono variabili speciali utilizzate per memorizzare indirizzi anziché valori.

Sintassi del puntatore

Ecco come possiamo dichiarare i puntatori.

 int* p;

Qui abbiamo dichiarato un puntatore p di inttipo.

Puoi anche dichiarare i puntatori in questi modi.

 int *p1; int * p2;

Facciamo un altro esempio di dichiarazione dei puntatori.

 int* p1, p2;

Qui abbiamo dichiarato un puntatore p1 e una normale variabile p2.

Assegnazione di indirizzi ai puntatori

Facciamo un esempio.

 int* pc, c; c = 5; pc = &c;

Qui, 5 è assegnato alla variabile c. Inoltre, l'indirizzo di c viene assegnato al puntatore del PC.

Ottieni il valore della cosa indicata dai puntatori

Per ottenere il valore della cosa puntata dai puntatori, usiamo l' *operatore. Per esempio:

 int* pc, c; c = 5; pc = &c; printf("%d", *pc); // Output: 5

Qui, l'indirizzo di cviene assegnato al puntatore del PC. Per ottenere il valore memorizzato in quell'indirizzo, abbiamo utilizzato * pc.

Nota: nell'esempio sopra, pc è un puntatore, non *pc. Non puoi e non dovresti fare qualcosa di simile *pc = &c;

A proposito, *viene chiamato operatore di dereferenziazione (quando si lavora con i puntatori). Funziona su un puntatore e fornisce il valore memorizzato in quel puntatore.

Modifica del valore puntato dai puntatori

Facciamo un esempio.

 int* pc, c; c = 5; pc = &c; c = 1; printf("%d", c); // Output: 1 printf("%d", *pc); // Ouptut: 1

Abbiamo assegnato l'indirizzo di c al puntatore del pc.

Quindi, abbiamo cambiato il valore di c in 1. Poiché pc e l'indirizzo di c sono gli stessi, *pcci dà 1.

Facciamo un altro esempio.

 int* pc, c; c = 5; pc = &c; *pc = 1; printf("%d", *pc); // Ouptut: 1 printf("%d", c); // Output: 1

Abbiamo assegnato l'indirizzo di c al puntatore del pc.

Then, we changed *pc to 1 using *pc = 1;. Since pc and the address of c is the same, c will be equal to 1.

Let's take one more example.

 int* pc, c, d; c = 5; d = -15; pc = &c; printf("%d", *pc); // Output: 5 pc = &d; printf("%d", *pc); // Ouptut: -15

Initially, the address of c is assigned to the pc pointer using pc = &c;. Since c is 5, *pc gives us 5.

Then, the address of d is assigned to the pc pointer using pc = &d;. Since d is -15, *pc gives us -15.

Example: Working of Pointers

Let's take a working example.

 #include int main() ( int* pc, c; c = 22; printf("Address of c: %p", &c); printf("Value of c: %d", c); // 22 pc = &c; printf("Address of pointer pc: %p", pc); printf("Content of pointer pc: %d", *pc); // 22 c = 11; printf("Address of pointer pc: %p", pc); printf("Content of pointer pc: %d", *pc); // 11 *pc = 2; printf("Address of c: %p", &c); printf("Value of c: %d", c); // 2 return 0; )

Output

 Address of c: 2686784 Value of c: 22 Address of pointer pc: 2686784 Content of pointer pc: 22 Address of pointer pc: 2686784 Content of pointer pc: 11 Address of c: 2686784 Value of c: 2

Explanation of the program

  1. int* pc, c;

    Here, a pointer pc and a normal variable c, both of type int, is created.
    Since pc and c are not initialized at initially, pointer pc points to either no address or a random address. And, variable c has an address but contains random garbage value.
  2. c = 22;

    This assigns 22 to the variable c. That is, 22 is stored in the memory location of variable c.
  3. pc = &c;

    This assigns the address of variable c to the pointer pc.
  4. c = 11;

    This assigns 11 to variable c.
  5. *pc = 2;

    This change the value at the memory location pointed by the pointer pc to 2.

Common mistakes when working with pointers

Suppose, you want pointer pc to point to the address of c. Then,

 int c, *pc; // pc is address but c is not pc = c; // Error // &c is address but *pc is not *pc = &c; // Error // both &c and pc are addresses pc = &c; // both c and *pc values *pc = c;

Here's an example of pointer syntax beginners often find confusing.

 #include int main() ( int c = 5; int *p = &c; printf("%d", *p); // 5 return 0; )

Why didn't we get an error when using int *p = &c;?

It's because

 int *p = &c;

is equivalent to

 int *p: p = &c;

In entrambi i casi, stiamo creando un puntatore p(not *p) e assegnandogli &c.

Per evitare questa confusione, possiamo usare l'affermazione in questo modo:

 int* p = &c;

Ora che sai cosa sono i puntatori, imparerai come i puntatori sono correlati agli array nel prossimo tutorial.

Articoli interessanti...