Note Ingegneria Informatica · UniTN
Programmazione 1
Esercizi
Lezione
ott, giorno?
in corso

Puntatori

Argomento di Programmazione 1. Fatto a lezione a ottobre, deck 6.1 per intero: slide 3-15 (cos’è un puntatore, dichiarazione, typedef), slide 16-31 (operatori * e &, esercizi, doppio puntatore), slide 32-42 (* e ++, assegnazione fra puntatori, aliasing, ->), slide 43-53 (array, stringhe, aritmetica dei puntatori), slide 54-63 (const, array di puntatori, sommario), slide 64-76 (esercizi finali). Il deck cita funzioni e allocazione dinamica solo come motivazione (slide 3): arrivano con i deck 6.2 e successivi. Prima: Array, Stringhe, Struct, typedef ed enum. Dopo: Funzioni.

Il filo del deck:

assegnazione x = a     finora si lavorava solo sui valori (right value) delle variabili
   |
puntatore              una variabile il cui valore è un indirizzo: "punta" a un'altra
   |
dichiarazione          TipoDato *P;   il tipo dice a cosa può puntare
   |
operatori              &x  indirizzo di x        *P  la variabile puntata da P
   |
assegnazioni           P = Q copia l'indirizzo (alias)   *P = *Q copia il valore
   |
struct                 (*P).campo  si scrive  P->campo
   |
array                  il nome dell'array è l'indirizzo di a[0]: a[i] è *(a + i)
aritmetica             p + i salta i ELEMENTI, p - q conta gli elementi in mezzo
   |
const, array di        puntatore costante, dati costanti; const char *semi[4]
puntatori

1Definizioni

Da dove si parte (slide 3-4). I puntatori sono uno dei punti di forza del C (servono per costruire funzioni, per l’allocazione dinamica, per l’efficienza) e una delle cause di errori più frequenti. Si parte dall’assegnazione: x = a; vuol dire “preleva il valore contenuto nella cella identificata da a e memorizzalo nella cella denotata da x”. Una variabile ha un left value (la cella, cioè l’indirizzo) e un right value (il contenuto), come in Il Linguaggio C. Finora si usava solo il right value; i puntatori rendono l’indirizzo un valore come gli altri.

Puntatore (slide 5-8). In C il puntatore è una variabile che memorizza, come right value, un indirizzo di memoria. Questo indirizzo è la locazione di un’altra variabile: “la prima variabile punta alla seconda”.

Nella figura p sta all’indirizzo 1000 e contiene 1012, che è l’indirizzo di x: p punta a x. Le slide usano indirizzi come 1000 e 1003 con celle “da una posizione”; con gcc a 64 bit un int occupa 4 byte e un puntatore 8, ma il disegno resta lo stesso: un riquadro per variabile, dentro il valore, fuori l’indirizzo. La freccia è solo un modo di disegnare “il valore di p è l’indirizzo di x”.

Dichiarazione (slide 10-13). Una variabile che contiene un indirizzo deve essere dichiarata in modo appropriato:

TipoDato *P;

Il * in una dichiarazione si applica all’identificatore che segue:

int *totale, *intermedio;      due puntatori a int
int NumUtenti, *NumChiamate;   un int e un puntatore a int
char* primo;                   valido
char *secondo;                 valido, preferibile: lo stesso * che lega a "secondo"

Il motivo della preferenza: char* a, b; sembra dichiarare due puntatori, ma b è un char. Scrivendo l’asterisco attaccato al nome, char *a, b;, si vede.

La slide 12 chiama il * della dichiarazione “operatore unario di dereferenziazione”. Nella dichiarazione è solo la sintassi che dice “puntatore a”; l’operatore * è quello delle espressioni, sotto. Il legame fra i due: int *P; si legge “l’espressione *P è un int”.

Tipo puntatore con typedef (slide 14-15). Per leggibilità si può dare un nome al tipo puntatore:

typedef int TipoDato;
typedef TipoDato *TipoPuntatore;    TipoPuntatore è "puntatore a TipoDato"
TipoPuntatore P;                    il right value di P è l'indirizzo di un TipoDato

Le slide del deck usano sempre questa forma. Nel codice delle note si scrive int *p direttamente, che è più comune.

Operatore &, indirizzo-di (slide 24-27). &x è l’indirizzo della variabile x, cioè il suo left value. Dopo P = &x; la variabile P punta a x. Si applica solo a oggetti in memoria: variabili, elementi di array, campi di struct. Non si applica a espressioni (&(x + 1)), costanti (&5) o variabili register (che potrebbero stare in un registro della CPU, senza indirizzo). È lo stesso & di scanf("%d", &x): scanf vuole sapere dove scrivere.

L’esempio della slide 26: con TipoPuntatore P, Q; TipoDato x, y; le istruzioni P = &y; Q = &x; fanno puntare P a y e Q a x. I nomi non devono “corrispondere”: un puntatore può ricevere l’indirizzo di qualunque variabile del tipo giusto.

Operatore *, dereferenziazione (slide 16-18). Se P contiene un indirizzo, *P denota la variabile il cui indirizzo è contenuto in P. Non è una copia: è la variabile stessa, usata attraverso un altro nome. Quindi *P si usa da entrambe le parti di un’assegnazione:

*P = x;     assegna il right value di x alla variabile puntata da P   (scrive)
x = *P;     assegna a x il right value della variabile puntata da P   (legge)

& e * sono uno l’inverso dell’altro: *&x è x, e se P punta a x allora &*P è P. Stanno nel gruppo degli operatori unari, con !, ++, --, sizeof e il cast, associatività da destra a sinistra (tabella della slide 30).

NULL (slide 62). Un puntatore si può inizializzare con NULL, un valore speciale che vuol dire “non punta a niente”. Se P vale NULL, *P è indefinito: su Linux il programma termina con segmentation fault. Un puntatore deve essere inizializzato prima di essere usato: un puntatore locale non inizializzato contiene un indirizzo a caso, e *P = 3 scrive in una cella a caso. NULL almeno si può controllare: if (P != NULL).

Aliasing (slide 40). Si ha aliasing quando lo stesso oggetto è identificato in due modi diversi: per esempio da due puntatori che contengono lo stesso indirizzo. Allora un’assegnazione esplicita alla variabile puntata da Q provoca un’assegnazione nascosta alla variabile puntata da P. È un effetto collaterale (side effect): il prof lo segna “da evitare”, perché chi legge *Q = 7 non si accorge che sta cambiando anche *P.

Puntatore costante (const, slide 54-57). const informa il compilatore che un valore non deve essere modificato. Serve per il principio del privilegio minimo: dare a ogni parte del programma solo l’accesso che le serve per il suo compito, “ma assolutamente nient’altro”. Quindi evitare le variabili globali, e usare const per tutto ciò che non deve cambiare. Con i puntatori il const può stare in due posti, e dice cose diverse:

dichiarazionesi può cambiare *p?si può cambiare p?come si legge (da destra)
int *psìsìp è un puntatore a int
const int *pnosìp è un puntatore a int costante
int *const psìnop è un puntatore costante a int
const int *const pnonop è un puntatore costante a int costante

La regola per non confondersi: const si riferisce a quello che ha subito a sinistra (o, se è il primo, a quello che ha subito a destra). In int *const p è il puntatore a essere costante; in const int *p è l’int.

2Concetti

2.1Assegnazioni con * e &, disegnate

(slide 19-26) Con P che punta a una variabile anonima (nelle slide un riquadro senza nome) e una variabile x:

*P = 14;    la cella puntata da P vale 14         P → [14]     x [ ? ]
x = 23;                                           P → [14]     x [23]
*P = x;     la cella puntata da P prende 23       P → [23]     x [23]

e nella slide 22-23, partendo da P → [14] e x [23]:

x = *P;     x prende il valore della cella puntata  P → [14]   x [14]

P non si muove mai: cambia solo il contenuto della cella in fondo alla freccia (con *P = ...) o di x.

Un secondo esempio, in cui il puntatore invece si sposta a metà strada. Prima di leggere la soluzione prova a dire quanto valgono a, b e *p alla fine.

#include <stdio.h>

int main(void)
{
    int a = 2;
    int b = 5;
    int *p = &a;

    *p = *p + b;
    p = &b;
    *p = *p * 2;
    printf("a=%d b=%d *p=%d\n", a, b, *p);
    return 0;
}
istruzionecambia una freccia o un valore?p punta aab*p
dichiarazionia252
*p = *p + b;valore: 2+52 + 5 scritto in aa757
p = &b;freccia: ora punta a bb755
*p = *p * 2;valore: 5⋅25 \cdot 2 scritto in bb71010

Output (verificato): a=7 b=10 *p=10. La domanda da farsi a ogni riga è quella della colonna 2: se a sinistra dell’= c’è p, si sposta la freccia; se c’è *p, si scrive nella cella in fondo alla freccia.

2.2P = Q contro *P = *Q

(slide 36-39) Partendo da y 14 e z 23, P = &y e Q = &z. La domanda della slide 38: “È vero che P = Q equivale a *P = *Q?” No.

Il programma che lo verifica, con anche l’effetto nascosto della slide 40:

#include <stdio.h>

int main(void)
{
    int y = 14;
    int z = 23;
    int *p = &y;
    int *q = &z;

    *p = *q;
    printf("dopo *p = *q: y=%d z=%d, p punta a %s\n", y, z, p == &y ? "y" : "z");
    y = 14;
    p = q;
    printf("dopo p = q:   y=%d z=%d, p punta a %s\n", y, z, p == &y ? "y" : "z");
    *q = 7;
    printf("dopo *q = 7:  *p=%d\n", *p);
    return 0;
}

Output (verificato):

dopo *p = *q: y=23 z=23, p punta a y
dopo p = q:   y=14 z=23, p punta a z
dopo *q = 7:  *p=7

L’ultima riga è l’aliasing: nessuna istruzione nomina *p, eppure *p è cambiato.

La sequenza della slide 40, “attenzione ai rischi dei puntatori”: *P = 3; *Q = 5; P = Q; e poi *Q = 7;. La slide chiede quanto vale *P dopo la terza e dopo la quarta istruzione. Con due variabili y e z al posto delle celle anonime:

#include <stdio.h>

int main(void)
{
    int x = 1;
    int y = 2;
    int *p = &x;
    int *q = &y;

    *p = 3;
    *q = 5;
    p = q;
    printf("*p=%d\n", *p);
    *q = 7;
    printf("x=%d y=%d *p=%d *q=%d\n", x, y, *p, *q);
    return 0;
}

(Nel programma le due variabili si chiamano x e y, nella figura y e z: conta solo che siano due.)

istruzionep punta aq punta axy*p
dichiarazionixy121
*p = 3;xy323
*q = 5;xy353
p = q;yy355
*q = 7;yy377

Output (verificato): *p=5, poi x=3 y=7 *p=7 *q=7. Le risposte della slide: dopo P = Q *P vale 5, dopo *Q = 7 vale 7. x resta 3 per sempre: dopo p = q nessun puntatore la raggiunge più.

Confrontare due puntatori con l’uguaglianza (p <mark> q) dice se puntano alla stessa cella, non se le celle contengono lo stesso valore (per quello: *p </mark> *q).

2.3Ammissibile o no: il controllo dei tipi

La domanda 1 della provetta chiede se un’istruzione è ammissibile. In queste note “ammissibile” vuol dire: gcc la compila senza errori e senza warning con -std=c11 -Wall -Wextra -Wpedantic. Ogni riga sotto è stata compilata così, da sola, dopo le dichiarazioni.

Il controllo si fa sui tipi dei due lati, con tre regole:

&x        aggiunge un livello:   x int     ->  &x int *
*p        toglie un livello:     p int *   ->  *p int
          p int **  ->  *p int *  ->  **p int
v (array) vale &v[0]:            v int[4]  ->  v int *      ma  &v  è  int (*)[4]

Poi a sinistra dell’= ci deve essere qualcosa che si può modificare (una variabile, *p, v[i], un campo), e i due lati devono avere lo stesso tipo puntato. Le forme che tornano sempre, con il messaggio di gcc 16:

istruzioneperchéesito, messaggio di gcc
p = &x; con int x; int *p;int * = int *SI
*p = x;int = intSI
p = x;int * = intNO, error: assignment to 'int *' from 'int' makes pointer from integer without a cast
*p = &x;int = int *NO, error: assignment to 'int' from 'int *' makes integer from pointer without a cast
pd = &x; con double *pd;double * = int *NO, error: assignment to 'double *' from incompatible pointer type 'int *'
&x = p;&x non è una variabileNO, error: lvalue required as left operand of assignment
p = &5;5 non sta in memoriaNO, error: lvalue required as unary '&' operand
v = p; con int v[4];l’array non si riassegnaNO, error: assignment to expression with array type
v++;idemNO, error: lvalue required as increment operand

I messaggi makes pointer from integer e incompatible pointer type, fino a gcc 13, erano solo warning: il programma compilava lo stesso con un indirizzo trattato come intero. Da gcc 14 sono errori. In tutti e due i casi la risposta è NO.

Esempio 1, la domanda 1 della prova del 22/10/2024 (prova 2024, pagina 1). Dato int i=1; int* pi; pi=&i;, sono ammissibili?

istruzionetipiesito
*pi=7;int = intSI: i diventa 7
pi=i;int * = intNO: error: ... makes pointer from integer without a cast
*pi=i;int = intSI: assegna a i il suo stesso valore
*pi++;è *(pi++)compila, ma warning: value computed is not used

L’ultima merita attenzione. È C valido: sposta pi sulla cella dopo i e legge *pi vecchio, buttando via il valore letto. Non incrementa i (servirebbe (*pi)++). Con la regola di queste note, warning vuol dire NO; il testo d’esame non ha la soluzione ufficiale, quindi se c’è spazio scrivi accanto il motivo: “compila ma incrementa il puntatore, non i, e il valore letto non viene usato”.

Le quattro affermazioni della stessa domanda:

Esempio 2, livello più alto. Con int x = 3; int *p = &x; int **pp = &p; const int *pc = &x;:

istruzionetipiesito
**pp = 5;int = intSI: x diventa 5
*pp = &x;int * = int *SI: p torna a puntare a x
pp = &x;int ** = int *NO, error: assignment to 'int **' from incompatible pointer type 'int *'
*pc = 4;scrive attraverso un const int *NO, error: assignment of read-only location '*pc'
pc = p;da int * a const int *: aggiunge una promessaSI
p = pc;da const int * a int *: toglie la promessaNO, warning: assignment discards 'const' qualifier from pointer target type

Le ultime due sono asimmetriche: si può passare da “posso scrivere” a “prometto di non scrivere”, non il contrario, altrimenti si potrebbe scrivere attraverso p in una cella che pc aveva promesso di non toccare.

2.4* e ++ insieme

(slide 32-35) Con int x = 1; int *ip = &x;:

*ip = *ip + 10;     x vale 11
*ip += 1;           x vale 12
++*ip;              x vale 13
(*ip)++;            x vale 14

Le ultime tre incrementano tutte di 1 la variabile puntata, e nessuna tocca ip. La domanda della slide 35: “il risultato cambiava senza le parentesi?” Sì. *ip++ incrementa il puntatore, non x.

Il perché. La slide dice che * e ++ “hanno stessa priorità ed associano a destra”. Vale per il ++ prefisso: in ++*ip gli operatori unari si applicano da destra, prima *ip (la variabile), poi ++. Il ++ postfisso invece ha precedenza più alta degli unari (sta nel gruppo della notazione suffissa con () e []; la tabella della slide 30 lo mette con gli unari, ed è un’imprecisione). Quindi:

espressionesi leggecosa incrementavalore dell’espressione
*p++*(p++)il puntatore, dopola cella puntata prima
(*p)++la variabile puntata, dopoil vecchio valore della variabile
++*p++(*p)la variabile puntata, primail nuovo valore della variabile
*++p*(++p)il puntatore, primala cella successiva

Tracciato su un array:

#include <stdio.h>

int main(void)
{
    int a[3] = {10, 20, 30};
    int *p = a;
    int v;

    v = *p++;
    printf("v=%d *p=%d a[0]=%d\n", v, *p, a[0]);
    v = (*p)++;
    printf("v=%d *p=%d a[1]=%d\n", v, *p, a[1]);
    v = *++p;
    printf("v=%d *p=%d\n", v, *p);
    v = ++*p;
    printf("v=%d a: %d %d %d\n", v, a[0], a[1], a[2]);
    return 0;
}
istruzionevp punta aa
inizialea[0]10 20 30
v = *p++10 (valore di a[0])a[1]10 20 30
v = (*p)++20 (vecchio a[1])a[1]10 21 30
v = *++p30 (nuova cella)a[2]10 21 30
v = ++*p31 (nuovo a[2])a[2]10 21 31

Output (verificato):

v=10 *p=20 a[0]=10
v=20 *p=21 a[1]=21
v=30 *p=30
v=31 a: 10 21 31

L’esercizio della slide 67-69 è il caso più frequente: con int arr[3] = {0, 0, 0}; int *p = arr; l’istruzione *p++ = 20; assegna 20 ad arr[0] e poi sposta p su arr[1]. Dopo: arr è {20, 0, 0} e p punta ad arr[1] (verificato). È l’idioma per riempire un array cella dopo cella.

2.5Doppio puntatore

(slide 31) Un puntatore è una variabile, quindi ha un indirizzo, e si può puntare anche lui. Un puntatore a puntatore (int **) contiene l’indirizzo di un int *.

Per arrivare all’int servono due dereferenziazioni: *doppio_ptr è ptr, **doppio_ptr è x.

2.6Puntatori e struct: l’operatore ->

(slide 41-42) Con TipoDato x, *P; P = &x; dove TipoDato è una struct, al campo di x attraverso P si accede con

(*P).PrimoCampo = 12;      prima la variabile puntata, poi il campo
P->PrimoCampo = 12;        la stessa cosa, abbreviata

La domanda della slide: “erano necessarie le parentesi?” Sì: il punto ha precedenza più alta di *, quindi *P.PrimoCampo si leggerebbe *(P.PrimoCampo), cioè “il campo di P” (che non è una struct, è un puntatore: non compila). L’operatore -> (puntatore a struttura) esiste per non scrivere ogni volta le parentesi, e sta nel gruppo di precedenza più alta con .. La regola: punto se a sinistra c’è una struct, freccia se c’è un puntatore a struct.

#include <stdio.h>

typedef struct {
    int primo_campo;
    char secondo_campo;
} tipo_dato;

int main(void)
{
    tipo_dato x;
    tipo_dato *p;

    p = &x;
    (*p).primo_campo = 12;
    p->secondo_campo = 'k';
    printf("%d %c\n", x.primo_campo, x.secondo_campo);
    p->primo_campo++;
    printf("%d\n", x.primo_campo);
    return 0;
}

Output (verificato): 12 k e 13. p->primo_campo++ incrementa il campo: -> e ++ postfisso stanno nello stesso gruppo, con associatività da sinistra a destra, quindi prima si valuta p->primo_campo, poi ++.

2.7Array e puntatori

(slide 43, 47-48) L’identificatore di un array è considerato in C come l’indirizzo del suo primo elemento (quello di indice 0). Due conseguenze:

Quindi, con int a[5]; int *p;:

p = a;          equivalente a   p = &a[0];
p = a + 1;      equivalente a   p = &a[1];
a[i]            equivalente a   *(a + i)
p[i]            equivalente a   *(p + i)
a = p;          ERRORE: a non si può riassegnare
a = a + 1;      ERRORE, stesso motivo (a++ idem)

Questo spiega tre cose viste nelle note precedenti: perché printf("%d", voti) stampava un indirizzo (Array), perché in scanf("%s", parola) non si mette & (Stringhe), perché un array non si assegna in blocco.

2.8Aritmetica dei puntatori

(slide 46-52) I puntatori possono stare in espressioni aritmetiche, assegnazioni e confronti, ma con un insieme limitato di operazioni:

Moltiplicare, dividere o sommare due puntatori non ha senso e non compila.

Il punto chiave della slide 51: p + i non aggiunge ii all’indirizzo, aggiunge ii elementi. Il puntatore avanza di i⋅i \cdot sizeof del tipo puntato. Con int da 4 byte e p uguale a 1000, p + 2 vale 1008 e punta ad a[2]. È per questo che il tipo del puntatore conta: un char * avanzerebbe di 1 byte, un double * di 8.

Simmetricamente (slide 52), se p e q puntano a due elementi dello stesso array, q - p è il numero di elementi fra i due, non la differenza in byte. Si stampa con %td (il tipo è ptrdiff_t).

#include <stdio.h>

int main(void)
{
    int a[5] = {10, 9, 0, -1, 8};
    int *p = a;
    int *q = &a[4];

    p = p + 2;
    printf("*p=%d p[1]=%d q-p=%td\n", *p, p[1], q - p);
    printf("byte fra p e q: %td\n", (char *)q - (char *)p);
    printf("%d %d\n", *(a + 3), *a + 3);
    return 0;
}

Output (verificato):

*p=0 p[1]=-1 q-p=2
byte fra p e q: 8
-1 13

2.9Stringhe: array di char e puntatore a char

(slide 44-45) Due dichiarazioni che sembrano uguali:

char amesg[] = "It is the time";
char *pmesg  = "It is the time";

Il programma della slide 45, senza le due righe che la slide stessa segna come errore (*stringa1 = 'T' su una costante):

#include <stdio.h>

int main(void)
{
    const char *stringa1 = "Hello world!";
    char stringa2[] = "This is me again";

    printf("stringa1=%s\n", stringa1);
    printf("*stringa1: %c\n", *stringa1);
    printf("*++stringa1: %c\n", *++stringa1);
    printf("stringa1=%s\n", stringa1);
    stringa1 = stringa2;
    printf("stringa1=%s\n", stringa1);
    *stringa2 = 'O';
    printf("stringa2=%s\n", stringa2);
    stringa2[1] = 'H';
    printf("stringa1=%s\n", stringa1);
    printf("sizeof: %zu %zu\n", sizeof(stringa1), sizeof(stringa2));
    return 0;
}

Output (verificato):

stringa1=Hello world!
*stringa1: H
*++stringa1: e
stringa1=ello world!
stringa1=This is me again
stringa2=Ohis is me again
stringa1=OHis is me again
sizeof: 8 17

Passo per passo:

2.10Array di puntatori

(slide 59-60) Si possono costruire array i cui elementi sono puntatori. L’esempio tipico è un array di stringhe:

const char *semi[4] = {"Cuori", "Quadri", "Picche", "Fiori"};

semi è un array di 4 elementi, ciascuno un puntatore a char che punta al primo carattere di una costante stringa. const dice che le stringhe non verranno modificate. Le stringhe hanno lunghezze diverse (6, 7, 7, 6 celle con il terminatore), e ognuna occupa solo lo spazio che le serve.

L’alternativa (la domanda della slide 60) è una matrice di caratteri char semi[4][7]: numero fisso di colonne, scelto sulla stringa più lunga, quindi spreco di memoria per le più corte.

#include <stdio.h>

int main(void)
{
    const char *semi[4] = {"Cuori", "Quadri", "Picche", "Fiori"};
    int i;

    for (i = 0; i < 4; i++)
        printf("%s %c %zu\n", semi[i], semi[i][1], sizeof(semi[i]));
    printf("%zu\n", sizeof(semi));
    return 0;
}

Output (verificato):

Cuori u 8
Quadri u 8
Picche i 8
Fiori i 8
32

semi[i][1] è il secondo carattere della stringa i: semi[i] è un puntatore, e [1] gli si applica come a un array. sizeof(semi[i]) è sempre 8 perché è un puntatore, e sizeof(semi) è 4⋅8=324 \cdot 8 = 32: le stringhe stanno altrove.

2.11Sommario e linguaggi

(slide 61-63) Le operazioni su una variabile puntatore: assegnazione di un indirizzo con & (P = &x), dereferenziazione con * (*P = x), assegnazione di un altro puntatore (P = Q), inizializzazione con NULL. Le regole: un puntatore va inizializzato prima dell’uso, *P con P NULL è indefinito, attenzione all’aliasing. I puntatori e la loro aritmetica fanno del C un linguaggio di basso livello (adatto per esempio ai driver di UNIX); Java non permette di manipolare puntatori e indirizzi.

3Metodo

Tracciare un programma con puntatori.

  1. Disegna un riquadro per ogni variabile, con il nome accanto. Se servono, scrivi gli indirizzi.
  2. Per ogni puntatore, una freccia verso la cella a cui punta (o la scritta NULL, o ? se non è inizializzato).
  3. A ogni istruzione chiediti: cambia una freccia (assegnazione a p: p = &x, p = q, p++) o cambia un valore in fondo a una freccia (assegnazione a *p)?
  4. Con un array, disegnalo come riga di celle con gli indici e fai muovere la freccia di p lungo la riga; p - a è l’indice a cui punta.

Leggere un’espressione con * e ++. Il postfisso lega per primo: *p++ è *(p++). Prefisso e * si applicano da destra a sinistra: ++*p è ++(*p), *++p è *(++p). Poi: il postfisso usa il valore vecchio, il prefisso quello nuovo.

Decidere se un’assegnazione fra puntatori è corretta (domanda 1 della provetta). Guarda i tipi dei due lati:

Dire quanto vale *p dopo una sequenza. Tabella con una colonna “p punta a” e una per ogni variabile. A ogni riga: se a sinistra c’è p (o p++, p += k) cambia solo la colonna della freccia; se c’è *p cambia la variabile indicata in quel momento dalla freccia. Alla fine *p è il valore della variabile a cui punta la freccia nell’ultima riga.

Scorrere un array con un puntatore.

for (p = a; p < a + N; p++)
    ...usa *p...

a + N punta “una cella dopo l’ultima”: si può calcolare e confrontare, non dereferenziare.

Scorrere una stringa con un puntatore.

p = s;
while (*p != '\0')
    p++;
p - s è la lunghezza

4Esempi svolti a lezione

4.1Assegnazione e stampa

(slide 28) Il primo esercizio: assegnare a ptr l’indirizzo di x, stampare valore e indirizzo, poi modificare x attraverso ptr. Gli indirizzi si stampano con %p, che vuole un void *: il codice della slide passa &x e ptr senza conversione, e con -Wpedantic gcc lo segnala come errore di formato. Versione corretta:

#include <stdio.h>

typedef int tipo_dato;
typedef tipo_dato *tipo_puntatore;

int main(void)
{
    tipo_puntatore ptr;
    tipo_dato x = 10;

    ptr = &x;
    printf("Value of x: %d\n", x);
    printf("Address of x: %p\n", (void *)&x);
    printf("Pointer (ptr) holds address: %p\n", (void *)ptr);
    printf("Value pointed to by ptr: %d\n", *ptr);
    *ptr = 100;
    printf("Value of x: %d\n", x);
    return 0;
}

Un’esecuzione (verificato):

Value of x: 10
Address of x: 0x7ffd864c2b8c
Pointer (ptr) holds address: 0x7ffd864c2b8c
Value pointed to by ptr: 10
Value of x: 100

Gli indirizzi cambiano a ogni esecuzione (il sistema operativo sposta lo stack a caso, per sicurezza), ma le righe 2 e 3 sono sempre uguali fra loro: il valore di ptr è l’indirizzo di x. L’ultima riga mostra che *ptr = 100 ha cambiato x senza nominarla. Gli indirizzi sono in esadecimale: 0x è il prefisso della base 16 (vedi Rappresentazione dell’informazione).

4.2Le variabili P e Q

(slide 29) Due puntatori inizializzati a NULL, poi P che punta a y, modifiche da entrambe le parti e infine Q = P:

#include <stdio.h>

typedef int tipo_dato;
typedef tipo_dato *tipo_puntatore;

int main(void)
{
    tipo_puntatore p = NULL;
    tipo_puntatore q = NULL;
    tipo_dato y = 10;

    printf("p=%p q=%p\n", (void *)p, (void *)q);
    printf("y=%d (prima di p=&y)\n", y);
    p = &y;
    *p = 14;
    printf("*p=%d\n", *p);
    printf("y=%d (dopo *p=14)\n", y);
    y++;
    printf("*p=%d\n", *p);
    q = p;
    printf("*q=%d\n", *q);
    printf("p e q uguali? %d\n", p == q);
    return 0;
}

Output (verificato):

p=(nil) q=(nil)
y=10 (prima di p=&y)
*p=14
y=14 (dopo *p=14)
*p=15
*q=15
p e q uguali? 1
istruzionepqy*p
inizialeNULLNULL10indefinito
p = &y→ yNULL1010
*p = 14→ yNULL1414
y++→ yNULL1515
q = p→ y→ y1515

(nil) è come la libreria di Linux stampa un puntatore NULL con %p. La riga y++ mostra il verso opposto dell’alias: si modifica y per nome e *p cambia, perché è la stessa cella.

4.3Doppio puntatore

(slide 31) Il programma della slide stampa x in tre modi; qui si aggiunge una scrittura attraverso il doppio puntatore:

#include <stdio.h>

typedef int tipo_dato;
typedef tipo_dato *tipo_puntatore;
typedef tipo_puntatore *doppio_puntatore;

int main(void)
{
    tipo_dato x = 42;
    tipo_dato y = 7;
    tipo_puntatore ptr = &x;
    doppio_puntatore doppio_ptr = &ptr;

    printf("x = %d\n", x);
    printf("*ptr = %d\n", *ptr);
    printf("**doppio_ptr = %d\n", **doppio_ptr);
    *doppio_ptr = &y;
    printf("*ptr = %d\n", *ptr);
    **doppio_ptr = 8;
    printf("x=%d y=%d\n", x, y);
    return 0;
}

Output (verificato):

x = 42
*ptr = 42
**doppio_ptr = 42
*ptr = 7
x=42 y=8

*doppio_ptr = &y cambia ptr (la variabile puntata da doppio_ptr): ora ptr punta a y. Quindi **doppio_ptr = 8 scrive in y, e x resta 42. È lo schema che servirà per far modificare un puntatore da una funzione (deck 6.2).

4.4Variabile puntatore e array

(slide 53) Lo stesso array visitato con l’indice, con l’aritmetica dei puntatori e infine spostando il puntatore. Al posto degli indirizzi assoluti (che cambiano a ogni esecuzione) si stampa la distanza in byte dal primo elemento:

#include <stdio.h>

int main(void)
{
    int a[5] = {10, 20, 30, 40, 50};
    int *ptr = a;
    int i;

    for (i = 0; i < 5; i++)
        printf("a[%d] = %d   *(p+%d) = %d   offset = %td byte\n",
               i, a[i], i, *(ptr + i), (char *)(ptr + i) - (char *)a);
    for (ptr = a; ptr < a + 5; ptr++)
        printf("%d ", *ptr);
    printf("\n");
    return 0;
}

Output (verificato):

a[0] = 10   *(p+0) = 10   offset = 0 byte
a[1] = 20   *(p+1) = 20   offset = 4 byte
a[2] = 30   *(p+2) = 30   offset = 8 byte
a[3] = 40   *(p+3) = 40   offset = 12 byte
a[4] = 50   *(p+4) = 50   offset = 16 byte
10 20 30 40 50 

Le prime due colonne sono uguali riga per riga (a[i] è *(a + i)); la terza mostra che ptr + i sta 4i4i byte dopo l’inizio. Il secondo ciclo usa il puntatore come indice: parte da a, avanza di un elemento a giro, si ferma quando arriva ad a + 5.

4.5const con i puntatori

(slide 56-57) Esempio 1, puntatore costante a dati non costanti: int *const ptr = &x; permette *ptr = 7 ma non ptr = &y. Esempio 2, puntatore costante a dati costanti: const int *const ptr = &x; permette solo di leggere (printf("%d", *ptr)). I messaggi di gcc sulle righe vietate (verificati):

int *const ptr = &x;          ptr = &y;      error: assignment of read-only variable 'ptr'
const int *const cptr = &x;   *cptr = 7;     error: assignment of read-only location '*cptr'
                              cptr = &y;     error: assignment of read-only variable 'cptr'
const int *pc = &x;           *pc = 7;       error: assignment of read-only location '*pc'
                              pc = &y;       consentito

Nota: x stessa non è const. Il const sul puntatore limita solo ciò che si può fare attraverso quel puntatore: x = 7 per nome resta permesso. È il privilegio minimo: chi riceve un const int * può leggere ma non scrivere.

4.6Lunghezza di una stringa con i puntatori

(slide 64-66) Tre versioni dello stesso calcolo su "Il sale della vita" (18 caratteri).

Versione 0, “cerca l’errore e correggi”: while (stringa++ != '\0') len++;. Manca l’asterisco: confronta il puntatore con '\0', non il carattere puntato. '\0' vale 0 e un puntatore confrontato con 0 è un confronto con NULL: la condizione è sempre vera e il ciclo va avanti oltre la stringa, all’infinito o fino al crash. gcc avvisa: “comparison between pointer and zero character constant”. La correzione è *stringa++.

Versione 1, “è corretto? cosa succede a stringa?”:

#include <stdio.h>

int main(void)
{
    int len = 0;
    const char *stringa = "Il sale della vita";

    while (*stringa++ != '\0')
        len++;
    printf("Lunghezza della stringa e' =%d\n", len);
    return 0;
}

Stampa Lunghezza della stringa e' =18 (verificato): la lunghezza è corretta. Ma stringa è stato spostato fino in fondo, e l’inizio della frase non è più raggiungibile. Peggio: *stringa++ incrementa anche quando legge il '\0', quindi alla fine stringa punta una cella dopo il terminatore. Il printf("%s", stringa) della slide legge fuori dalla stringa (comportamento indefinito).

Versione corretta: si scorre una copia del puntatore.

#include <stdio.h>

int main(void)
{
    int len = 0;
    const char *stringa = "Il sale della vita";
    const char *p;

    p = stringa;
    while (*p++ != '\0')
        len++;
    printf("Lunghezza della stringa: %s e' =%d\n", stringa, len);
    printf("p - stringa = %td\n", p - stringa);
    return 0;
}

Output (verificato):

Lunghezza della stringa: Il sale della vita e' =18
p - stringa = 19

stringa mantiene l’inizializzazione perché si muove solo p. La seconda riga conferma la cella in più: p si è fermato a 19 celle dall’inizio, uno dopo il terminatore (che sta a 18). La domanda nel commento della slide, “cosa succede se viene omessa la dereferenziazione?”, è la versione 0.

4.7Quali assegnazioni sono corrette

(slide 70-76) Con le dichiarazioni

typedef TipoDato *TipoPuntatore;
typedef AltroTipoDato *AltroTipoPuntatore;
TipoDato *Puntatore;
TipoDato **DoppioPuntatore;
TipoPuntatore P, Q;
AltroTipoPuntatore P1, Q1;
TipoDato x, y;
AltroTipoDato z, w;

le sei assegnazioni delle slide sono tutte corrette, con il tipo dei due lati:

assegnazionetipo a sinistratipo a destra
Puntatore = &yTipoDato *TipoDato *corretta
DoppioPuntatore = &PTipoDato **TipoPuntatore * cioè TipoDato **corretta
P = &xTipoDato *TipoDato *corretta
P = QTipoDato *TipoDato *corretta (alias)
*P = *QTipoDatoTipoDatocorretta se P e Q puntano a qualcosa
*Puntatore = xTipoDatoTipoDatocorretta (Puntatore punta a y)

Puntatore e P hanno lo stesso tipo: uno scritto per esteso, l’altro con il typedef. Le assegnazioni sbagliate sono quelle che mescolano i livelli o i tipi puntati; le vedi negli esercizi 1, 6, 12 e 14 di Puntatori (esercizi).

5Esercizi tipo esame

In una pagina a parte, dal più facile al livello del 30: Puntatori (esercizi).

6Errori tipici

7Domande