Approfondimento sui puntatori

Come usare un puntatore a dati, righe o funzioni

Siamo arrivati alla lezione che corona le prime quattro unità del corso e svela tutta la potenza espressiva del linguaggio C: l’approfondimento avanzato sui puntatori.

Nelle lezioni precedenti abbiamo visto l’idea base di puntatore (int *p = &x;) e il passaggio per indirizzo alle funzioni. Ora risponderemo a quattro domande fondamentali che distinguono un principiante da un vero programmatore C:

  1. Cosa succede esattamente quando sommiamo un intero a un puntatore (p + k) o sottraiamo due puntatori (p2 - p1)? (Aritmetica dei puntatori).
  2. Qual è la differenza tra const int *p, int * const p e const int * const p, e a cosa serve il puntatore universale void *?
  3. Cos’è un puntatore doppio (`int pp`)**, cioè un puntatore che punta a un altro puntatore?
  4. Come può un puntatore puntare non a dei dati, ma al codice di una funzione (int (*cmp)(...)), permettendo di passare una funzione come parametro a un’altra funzione (come nella celebre qsort)?

1. Aritmetica dei Puntatori

In C sui puntatori non si possono fare operazioni qualsiasi (ad esempio non si possono sommare né moltiplicare due puntatori tra loro), ma sono definite due operazioni geometriche potentissime:

a) Somma (o sottrazione) di un intero a un puntatore: p + k

Se p è un puntatore di tipo Tipo * che contiene l’indirizzo base , quanto vale l’indirizzo p + k (con )?

Regola fondamentale dell’Aritmetica dei Puntatori: Sommare a un puntatore Tipo *p NON aggiunge byte, ma fa avanzare l’indirizzo di elementi di quel tipo, cioè di byte!

  • Se char *pc vale 0x1000 (), allora pc + 1 vale 0x1001, e pc + 3 vale 0x1003.
  • Se int *pi vale 0x1000 (), allora pi + 1 vale 0x1004, e pi + 3 vale 0x100C ( byte)!
  • Se double *pd vale 0x1000 (), allora pd + 1 vale 0x1008, e pd + 3 vale 0x1018 ( byte)!

Da qui nasce l’equivalenza universale tra l’operatore parentesi quadre [] e l’aritmetica dei puntatori:

Di conseguenza:

  • Per un indice valido, &v[i] equivale a v + i. Nella maggior parte delle espressioni, un array come v si converte in un puntatore al primo elemento. Con sizeof v o &v si usa invece l’intero oggetto array.
  • Per scorrere un array di n elementi, partiamo da int *p = v e avanziamo finché p != v + n. La posizione v + n indica il limite subito oltre l’ultimo elemento. Si può confrontare con p, mentre l’ultimo elemento dereferenziabile è v + n - 1 quando n > 0.

Con int v[] = {2, 4, 6, 8}, il frammento for (int *p = v; p != v + 4; ++p) printf("%d ", *p); visita quattro celle in ordine e si arresta prima di leggere la posizione oltre il limite.

flowchart LR
    subgraph Aritmetica["Vettore int v[4] (sizeof(int) = 4 byte)"]
        direction LR
        C0["*(p + 0) = v[0]\nInd: 0x1000\n<-- p"] --- C1["*(p + 1) = v[1]\nInd: 0x1004\n<-- p + 1 (+4B)"] --- C2["*(p + 2) = v[2]\nInd: 0x1008\n<-- p + 2 (+8B)"] --- C3["*(p + 3) = v[3]\nInd: 0x100C\n<-- p + 3 (+12B)"]
    end

b) Differenza tra due puntatori dello stesso array: p2 - p1

Se p1 e p2 puntano a due elementi dello stesso vettore (es. p1 = &v[1] e p2 = &v[4]), la loro differenza p2 - p1 (di tipo ptrdiff_t) restituisce il numero di elementi di distanza tra i due puntatori (e NON la differenza in byte!):

Nell’esempio sopra, anche se gli indirizzi distano byte, &v[4] - &v[1] vale esattamente 3 ( elementi)!


2. Puntatore Generico void *, NULL e il qualificatore const

Il puntatore nullo NULL

Definito in <stddef.h> e <stdio.h>, NULL è una costante speciale (valore 0 o ((void *)0)) che garantisce che il puntatore non punta ad alcuna area di memoria valida. Prima di dereferenziare un puntatore che potrebbe essere nullo, si controlla sempre if (p != NULL).

Il puntatore generico (universale) void *

Un puntatore di tipo void * significa “indirizzo di memoria puro, senza un tipo associato”.

  • Vantaggio: qualunque puntatore tipizzato (int *, double *, Studente *) può essere assegnato a un void * (e viceversa in C) senza perdere l’indirizzo. È usato dalle funzioni generiche della libreria standard come fread, fwrite, memcpy, malloc e qsort.
  • Due limiti rigorosi del void *: poiché il compilatore non sa quanti byte occupi il dato puntato da un void *gp:
    1. NON si può dereferenziare direttamente *gp (prima bisogna fare un cast esplicito a un puntatore tipizzato, es. *(int *)gp).
    2. NON si può fare aritmetica dei puntatori gp + 1 in C standard (perché sizeof(void) non è definito!).

Le 3 combinazioni di const con i puntatori (Regola di lettura da destra a sinistra!)

Come distinguere dove agisce la parola const quando c’è un asterisco *? Basta guardare se const si trova a sinistra oppure a destra dell’asterisco *:

DichiarazioneCome si leggeIl puntatore p può cambiare freccia (p = &y)?Il dato puntato *p può essere modificato (*p = 99)?
const int *p
(o `int const p`)*
Puntatore (variabile) a un int costante (const è a sinistra di *)SÌ (p = &y; valido)NO! (*p = 99; Errore!)
int * const p = &xPuntatore costante a un int (variabile) (const è a destra di *)NO! (p = &y; Errore!)SÌ (*p = 99; valido)
const int * const p = &xPuntatore costante a un int costante (const sia a sinistra sia a destra)NO! (p = &y; Errore!)NO! (*p = 99; Errore!)

3. Puntatori Doppi (int **pp)

Se un puntatore int *p è esso stesso una variabile allocata in memoria dotata di un proprio indirizzo &p, quale tipo di variabile può contenere l’indirizzo &p? Un puntatore a puntatore (o puntatore doppio) `int pp`**!

int x = 42;
int *p = &x;   /* p contiene l'indirizzo di x   (*p vale 42)  */
int **pp = &p; /* pp contiene l'indirizzo di p  (*pp è p, e **pp è x = 42!) */
flowchart LR
    PP["int **pp\nValore: 0x1008\n(Ind: 0x1010)"] ==>|"*pp accede a p"| P["int *p\nValore: 0x1000\n(Ind: 0x1008)"]
    P ==>|"**pp (cioè *p)\naccede a x!"| X["int x = 42\n(Ind: 0x1000)"]

A cosa servono davvero i puntatori doppi in C?

  1. Modificare dove punta un puntatore dentro una funzione:
    Se vogliamo scrivere una funzione che cambi l’indirizzo contenuto dentro un puntatore int *p del main (ad esempio per farlo puntare a una nuova cella o azzerarlo a NULL), non basta passare p per valore: dobbiamo passare l’indirizzo del puntatore &p, e quindi la funzione deve ricevere `int pp`**!
  2. Vettori di stringhe (come char *argv[] ovvero `char argv)**: Una stringa è un char . Un elenco di parole (come gli argomenti passati da riga di comando al programma in int main(int argc, char argv[])) è quindi un vettore di char *, che decade a **char `!

4. Puntatori a Funzione e Callback (qsort)

In un computer moderno (architettura di von Neumann), anche il codice macchina compilato delle funzioni risiede in memoria RAM (nel segmento Text/Code) e ha quindi un indirizzo di memoria!
In C possiamo salvare l’indirizzo di una funzione dentro un puntatore a funzione e usarlo per invocare la funzione, oppure passarlo come argomento a un’altra funzione (Callback).

Sintassi di un puntatore a funzione

/* Puntatore 'op' a una qualsiasi funzione che prende due int e restituisce un int: */
int (*op)(int, int);

Attenzione alle parentesi attorno a (*op):

  • int (*op)(int, int); è un puntatore a una funzione che restituisce int.
  • int *op(int, int); (senza parentesi attorno a *op) è il prototipo di una funzione che restituisce un puntatore int *!

Esempio pratico: Ordinare qualunque vettore con qsort di <stdlib.h>

La libreria standard <stdlib.h> fornisce una funzione di ordinamento velocissima (), qsort, capace di ordinare un vettore di qualsiasi tipo (int, double, Studente):

void qsort(void *base, size_t n_elem, size_t dim_elem,
           int (*compar)(const void *, const void *));

Come fa qsort a sapere quale tra due elementi generici a e b viene prima? Glielo diciamo noi passandogli come quarto argomento un puntatore alla nostra funzione di confronto compar, che riceve i due indirizzi generici const void *a, const void *b e deve restituire:

  • < 0 se *a deve precedere *b;
  • 0 se *a e *b sono equivalenti;
  • > 0 se *a deve seguire *b.

Puntatori a righe e firme delle callback

int m[2][3] si converte in un puntatore alla prima riga di tipo int (*)[3]. Un parametro const int righe[][3] è adattato a const int (*righe)[3]. Per esempio, possiamo passare direttamente un array dichiarato const int m[2][3]. righe + 1 avanza di una riga e righe[1][2] legge l’ultima cella della seconda riga. Un int ** descrive invece un puntatore a oggetti int *. Per una sottrazione fra puntatori servono posizioni dello stesso array, compresa la posizione subito oltre la fine, e una differenza rappresentabile in ptrdiff_t.

Una callback deve avere la firma attesa. typedef int (*Confronto)(const void *, const void *); dà un nome al tipo di puntatore usato da qsort. La funzione confronta gli oggetti dopo aver interpretato correttamente i due indirizzi. La nota su ricerca e ordinamento mostra un comparatore che evita overflow. Per il passaggio dei parametri e la validità dei dati vedi funzioni e allocazione dinamica.


Esempi guidati

Esempio 1: Scansione e calcolo di strlen puramente con Aritmetica dei Puntatori

Vediamo quanto diventa compatta strlen usando la differenza tra due puntatori:

#include <stdio.h>
 
size_t mia_strlen_ptr(const char *s) {
    const char *fine = s; /* Parte dall'inizio della stringa */
    while (*fine != '\0') {
        fine++;           /* Avanza il puntatore di 1 char alla volta */
    }
    /* La differenza tra i due puntatori è esattamente il numero di caratteri! */
    return (size_t)(fine - s);
}
 
int main(void) {
    const char *msg = "Puntatori";
    printf("Lunghezza di \"%s\": %zu\n", msg, mia_strlen_ptr(msg)); /* Stampa 9 */
    return 0;
}

Esempio 2: Scambio di due puntatori tramite Puntatore Doppio (int **)

#include <stdio.h>
 
/* Scambia dove puntano i due puntatori pa e pb del main! */
void scambia_puntatori(int **ppa, int **ppb) {
    int *temp = *ppa;
    *ppa = *ppb;
    *ppb = temp;
}
 
int main(void) {
    int x = 10, y = 99;
    int *p1 = &x;
    int *p2 = &y;
 
    printf("Prima: *p1 = %d, *p2 = %d\n", *p1, *p2);
    scambia_puntatori(&p1, &p2); /* Passiamo gli indirizzi dei due puntatori! */
    printf("Dopo:  *p1 = %d, *p2 = %d (ma x=%d e y=%d non si sono mossi!)\n",
           *p1, *p2, x, y);
    return 0;
}

Esempio 3: Uso di Puntatori a Funzione e qsort per ordinare un array di interi

#include <stdio.h>
#include <stdlib.h>
 
/* Funzione di callback per qsort: ordina gli int in modo CRESCENTE */
int confronta_int_crescente(const void *a, const void *b) {
    /* 1. Convertiamo i puntatori generici void* in puntatori tipizzati const int* */
    int val_a = *(const int *)a;
    int val_b = *(const int *)b;
 
    /* 2. Restituiamo <0, 0 o >0 in modo sicuro senza rischio di overflow */
    if (val_a < val_b) return -1;
    if (val_a > val_b) return 1;
    return 0;
}
 
int main(void) {
    int v[6] = {42, -5, 18, 0, 99, 7};
 
    /* Passiamo a qsort il nome della funzione 'confronta_int_crescente' come puntatore! */
    qsort(v, 6, sizeof(int), confronta_int_crescente);
 
    printf("Ordinato con qsort: ");
    for (int i = 0; i < 6; i++) {
        printf("%d ", v[i]);
    }
    printf("\n");
    return 0;
}

Errori frequenti

Errori da evitare

  1. Moltiplicare manualmente per sizeof nell’aritmetica dei puntatori (p + i * sizeof(int))
    Errore gravissimo! Il compilatore moltiplica già da solo l’indice i per sizeof(*p)! Se su un int *p scrivete p + i * sizeof(int), il compilatore avanzerà di byte, saltando di 4 elementi alla volta e uscendo subito dai limiti del vettore! Scrivete sempre e solo p + i.
  2. Confondere *p++ con (*p)++
    • *p++: poiché l’operatore postfisso ++ ha precedenza più alta di *, equivale a *(p++): legge il valore attualmente puntato da p e fa avanzare il puntatore p alla cella successiva!
    • (*p)++: tiene fermo il puntatore p sulla stessa cella e incrementa di 1 il valore intero contenuto dentro quella cella!
  3. Sottrarre due puntatori che non appartengono allo stesso array
    L’operazione p2 - p1 (e i confronti <, >) ha senso ed è definita dallo standard C solo se p1 e p2 puntano a elementi dello stesso vettore (o alla cella immediatamente successiva all’ultimo elemento &v[N]).

Esercizi di prova

Esercizio 1. Aritmetica dei puntatori e precedenze *p++ vs (*p)++ (Base)

Senza eseguire il codice, determina il contenuto finale dell’array v e cosa stampa printf:

#include <stdio.h>
int main(void) {
    int v[4] = {10, 20, 30, 40};
    int *p = v;
    int a = *p++;
    int b = (*p)++;
    int c = *(p + 2);
    printf("a=%d, b=%d, c=%d | v={%d, %d, %d, %d}\n",
           a, b, c, v[0], v[1], v[2], v[3]);
    return 0;
}

Riparti poi da int v[4] = {2, 4, 6, 8}; e segui questo secondo frammento. Annota gli elementi modificati e il valore finale di p.

int *p = v;
*p = 1;
*(p + 2) = v[1] + v[3];
p = &v[3];
*p = v[0] + v[2];

Esercizio 2. Qualificatore const coi puntatori (Base)

Date due variabili int x = 10, y = 20; e le due dichiarazioni:

const int *p1 = &x;
int * const p2 = &x;

Indica quali delle seguenti 4 istruzioni sono valide e quali provocano un errore di compilazione:
a) *p1 = 50;
b) p1 = &y;
c) *p2 = 50;
d) p2 = &y;

Esercizio 3. Inversione di un array con due puntatori (Intermedio)

Scrivi una funzione void inverti_ptr(int *v, int n) che inverta sul posto un vettore di n interi usando esclusivamente due puntatori int *sx = v; e int *dx = v + n - 1; che si muovono l’uno verso l’altro finché sx < dx.

Esercizio 4. Traccia con puntatori doppi (int **) (Intermedio)

Determina cosa stampa il seguente programma seguendo con attenzione le frecce dei puntatori:

#include <stdio.h>
int main(void) {
    int a = 10, b = 20;
    int *p = &a;
    int **pp = &p;
    **pp = 30;
    *pp = &b;
    **pp = *p + a;
    printf("a = %d, b = %d\n", a, b);
    return 0;
}

Esercizio 5. Funzione che restituisce un puntatore all’elemento massimo (Avanzato)

Scrivi una funzione int *puntatore_al_massimo(int *v, int n) che riceva un vettore di n >= 1 interi e restituisca l’indirizzo di memoria (int *) della cella che contiene il valore massimo. Mostra poi come nel main sia possibile azzerare direttamente il valore massimo del vettore scrivendo *puntatore_al_massimo(v, 5) = 0;!
(Domanda teorica: perché restituire &v[i] è perfettamente sicuro, mentre restituire l’indirizzo di una variabile locale della funzione sarebbe un grave errore?)

Esercizio 6. Uso di Puntatori a Funzione per filtrare/contare elementi di un vettore (Avanzato)

Scrivi una funzione di ordine superiore:
int conta_se(const int v[], int n, int (*predicato)(int));
che riceva un array v di n interi e un puntatore a funzione predicato (una funzione che prende un int e restituisce 1 se soddisfa una proprietà, 0 altrimenti), e restituisca quanti elementi di v soddisfano predicato(v[i]).
Testala nel main passandole due diverse funzioni: int e_pari(int x) e int e_negativo(int x).


Provenienza del materiale

  • Slide e dispensa ufficiale del corso: C1PROG1U3L6_Approfondimento_Puntatori tag accessibilità.pdf (Unità 3, Lezione 6b — Approfondimento sui puntatori: aritmetica dei puntatori, void *, const, puntatori doppi e puntatori a funzione).
  • Marco Anisetti, Funzioni, Appunti_di_Fine_Unità_3.pdf, capp. 4 e 6.
  • Marco Anisetti, Memoria, Appunti_di_Fine_Unità_4.pdf, cap. 3.
  • WG14, bozza C11 N1570, §§ 6.3.2.1, 6.5.6 e 6.7.6.3.
  • Dispensa del corso, C1PROG1B3L4_Puntatori_e_Vettori.pdf (Memoria, puntatori e vettori).