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;
TipoDatodice quale tipo di variabile può essere puntata (unint *punta aint, non afloat);Pè l’identificatore della variabile puntatore;- l’asterisco dice che
Pè un puntatore.
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:
| dichiarazione | si può cambiare *p? | si può cambiare p? | come si legge (da destra) |
|---|---|---|---|
int *p | sì | sì | p è un puntatore a int |
const int *p | no | sì | p è un puntatore a int costante |
int *const p | sì | no | p è un puntatore costante a int |
const int *const p | no | no | p è 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;
}
| istruzione | cambia una freccia o un valore? | p punta a | a | b | *p |
|---|---|---|---|---|---|
| dichiarazioni | a | 2 | 5 | 2 | |
*p = *p + b; | valore: scritto in a | a | 7 | 5 | 7 |
p = &b; | freccia: ora punta a b | b | 7 | 5 | 5 |
*p = *p * 2; | valore: scritto in b | b | 7 | 10 | 10 |
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.
*P = *Qcopia il valore: la variabile puntata daP(cioèy) prende il valore di quella puntata daQ(23).Pcontinua a puntare ay. Dopo,yezvalgono entrambe 23 ma sono due celle separate.P = Qcopia l’indirizzo:Psmette di puntare aye punta az.yresta 14. Dopo,*Pe*Qsono la stessa cella: è aliasing.
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.)
| istruzione | p punta a | q punta a | x | y | *p |
|---|---|---|---|---|---|
| dichiarazioni | x | y | 1 | 2 | 1 |
*p = 3; | x | y | 3 | 2 | 3 |
*q = 5; | x | y | 3 | 5 | 3 |
p = q; | y | y | 3 | 5 | 5 |
*q = 7; | y | y | 3 | 7 | 7 |
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:
| istruzione | perché | esito, messaggio di gcc |
|---|---|---|
p = &x; con int x; int *p; | int * = int * | SI |
*p = x; | int = int | SI |
p = x; | int * = int | NO, 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 variabile | NO, error: lvalue required as left operand of assignment |
p = &5; | 5 non sta in memoria | NO, error: lvalue required as unary '&' operand |
v = p; con int v[4]; | l’array non si riassegna | NO, error: assignment to expression with array type |
v++; | idem | NO, 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?
| istruzione | tipi | esito |
|---|---|---|
*pi=7; | int = int | SI: i diventa 7 |
pi=i; | int * = int | NO: error: ... makes pointer from integer without a cast |
*pi=i; | int = int | SI: 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:
- “è possibile dereferenziare un puntatore non inizializzato”: NO. Compila, ma il puntatore contiene un indirizzo a caso e il risultato è indefinito; gcc avvisa
'p' is used uninitialized. - “la dichiarazione di un puntatore alloca memoria per la variabile puntata”: NO.
int *p;alloca solop(8 byte); la variabile puntata deve esistere già. - “2 variabili puntatore che si riferiscono a tipi diversi sono comunque compatibili tra loro”: NO.
pd = picondouble *pd; int *pi;èincompatible pointer type. - “lo spazio di memoria di un puntatore dipende dal tipo”: NO. Un puntatore contiene un indirizzo, e gli indirizzi hanno tutti la stessa dimensione:
sizeof(char *),sizeof(int *),sizeof(double *)esizeof(int **)valgono tutti 8 su una macchina a 64 bit (verificato).
Esempio 2, livello più alto. Con int x = 3; int *p = &x; int **pp = &p; const int *pc = &x;:
| istruzione | tipi | esito |
|---|---|---|
**pp = 5; | int = int | SI: 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 promessa | SI |
p = pc; | da const int * a int *: toglie la promessa | NO, 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:
| espressione | si legge | cosa incrementa | valore dell’espressione |
|---|---|---|---|
*p++ | *(p++) | il puntatore, dopo | la cella puntata prima |
(*p)++ | la variabile puntata, dopo | il vecchio valore della variabile | |
++*p | ++(*p) | la variabile puntata, prima | il nuovo valore della variabile |
*++p | *(++p) | il puntatore, prima | la 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;
}
| istruzione | v | p punta a | a |
|---|---|---|---|
| iniziale | a[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 = *++p | 30 (nuova cella) | a[2] | 10 21 30 |
v = ++*p | 31 (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:
a“punta” a una cella di memoria esattamente come un puntatore;apunta sempre al primo elemento: è un puntatore costante, a cui non si può assegnare un altro indirizzo.
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:
- incremento
++e decremento--; - somma di un intero (
+,+=) e sottrazione di un intero (-,-=); - differenza fra due puntatori allo stesso array;
- confronto (minore, maggiore, uguaglianza) fra puntatori allo stesso array.
Moltiplicare, dividere o sommare due puntatori non ha senso e non compila.
Il punto chiave della slide 51: p + i non aggiunge all’indirizzo, aggiunge elementi. Il puntatore avanza di 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
p = p + 2portapsua[2], che vale 0;p[1]è*(p + 1), cioèa[3], ;q - p: daa[2]ada[4]ci sono 2 elementi; in byte sono 8 (convertendo inchar *, che conta i byte);*(a + 3)èa[3], ;*a + 3è(*a) + 3, cioè , perché*lega più di+. Le parentesi cambiano tutto.
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";
amesgè un array dichargrande abbastanza per i 15 caratteri (14 più'\0'): la stringa viene copiata nell’array, che è tuo. I caratteri si possono modificare;amesgnon si può far puntare altrove.pmesgè una variabile puntatore che punta alla costante stringa"It is the time", che sta in una zona di sola lettura. Il puntatore si può cambiare e far puntare altrove; ma i tentativi di modificare la stringa costante sono indefiniti (spesso il programma termina con un errore). Per questo è buona norma dichiararloconst char *pmesg, così il compilatore rifiuta*pmesg = 'T'.
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:
*++stringa1: prima sposta il puntatore sul secondo carattere, poi lo legge:e. Da quistringa1“vede” la stringa daein poi;stringa1 = stringa2: legale,stringa1è una variabile puntatore. Il contrario,stringa2 = stringa1, non compila;*stringa2 = 'O':*stringa2èstringa2[0], e l’array è modificabile;- dopo
stringa2[1] = 'H', stampandostringa1si vede la modifica: è un alias distringa2; sizeof(stringa1)è la dimensione di un puntatore (8 byte), non della stringa;sizeof(stringa2)è la dimensione dell’array, .
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) è : 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.
- Disegna un riquadro per ogni variabile, con il nome accanto. Se servono, scrivi gli indirizzi.
- Per ogni puntatore, una freccia verso la cella a cui punta (o la scritta
NULL, o?se non è inizializzato). - 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)? - Con un array, disegnalo come riga di celle con gli indici e fai muovere la freccia di
plungo 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:
&xha tipo “puntatore al tipo dix”;*ptoglie un livello di puntatore;&pne aggiunge uno;- a sinistra e a destra deve esserci lo stesso tipo:
int *conint *,int **conint **,intconint; - un
int *non si assegna a unchar *, né un intero a un puntatore (tranne la costanteNULL); &richiede a destra un oggetto in memoria:&x = pe&5non hanno senso;- a sinistra serve qualcosa di modificabile: non un array (
v = p,v++), non unconst(*pc = 4conconst int *pc,cp = pconint *const cp); - con un array,
vèint *ma&vè “puntatore all’array intero”:p = &vè NO.
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
| istruzione | p | q | y | *p |
|---|---|---|---|---|
| iniziale | NULL | NULL | 10 | indefinito |
p = &y | → y | NULL | 10 | 10 |
*p = 14 | → y | NULL | 14 | 14 |
y++ | → y | NULL | 15 | 15 |
q = p | → y | → y | 15 | 15 |
(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 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:
| assegnazione | tipo a sinistra | tipo a destra | |
|---|---|---|---|
Puntatore = &y | TipoDato * | TipoDato * | corretta |
DoppioPuntatore = &P | TipoDato ** | TipoPuntatore * cioè TipoDato ** | corretta |
P = &x | TipoDato * | TipoDato * | corretta |
P = Q | TipoDato * | TipoDato * | corretta (alias) |
*P = *Q | TipoDato | TipoDato | corretta se P e Q puntano a qualcosa |
*Puntatore = x | TipoDato | TipoDato | corretta (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
- Usare un puntatore non inizializzato (
int *p; *p = 3;) o dereferenziareNULL. - Confondere
P = Q(sposta la freccia, crea un alias) con*P = *Q(copia il valore). - Scrivere
*p++per incrementare il valore puntato: incrementa il puntatore. Serve(*p)++. - Dimenticare l’asterisco nel confronto:
while (s++ != '\0')confronta il puntatore (slide 64). - Perdere l’inizio di una stringa o di un array spostando il puntatore originale invece di una copia (slide 65).
char* a, b;credendo di dichiarare due puntatori.*P.campoinvece diP->campoo(*P).campo: il punto lega più dell’asterisco.- Assegnare a un array (
a = p,a++) come se fosse una variabile puntatore. - Credere che
p + 1avanzi di un byte, o cheq - psia una differenza in byte. - Modificare una costante stringa attraverso un
char *(slide 44-45): dichiaraloconst char *. - Stampare un puntatore con
%do con%psenza la conversione avoid *. - Usare
sizeofsu un puntatore per sapere quanto è lunga la stringa o l’array a cui punta: dà la dimensione del puntatore (8). p = &vconvarray diint:&vè un puntatore all’array intero (int (*)[4]), non unint *. Si scrivep = vop = &v[0].- Assegnare un
const int *a unint *: gcc avvisa che si scarta ilconst. - Rispondere SI a “la dichiarazione di un puntatore alloca la variabile puntata”: alloca solo il puntatore.
7Domande
-
Cos’è un puntatore in C? Cosa vuol dire “la prima variabile punta alla seconda”?
-
Cosa indica
TipoDatonella dichiarazioneTipoDato *P;? Cosa dichiaraint *a, b;? -
Cosa fanno gli operatori
&e*? A cosa non si può applicare&? -
Che differenza c’è fra
P = Qe*P = *Q? -
Cos’è l’aliasing e perché è pericoloso?
-
Perché un puntatore va inizializzato? Cosa succede dereferenziando
NULL? -
Cosa fanno
*p++,(*p)++,++*pe*++p? -
A cosa serve l’operatore
->? Perché in(*P).camposervono le parentesi? -
Perché il nome di un array si comporta come un puntatore costante? Cosa ne segue per
a[i]e pera = p? -
Se
pè unint *, di quanti byte avanzap + 2? Cosa restituisceq - p? -
Che differenza c’è fra
char a[] = "testo";echar *p = "testo";? -
Che differenza c’è fra
const int *p,int *const peconst int *const p? Cos’è il principio del privilegio minimo? -
Perché un array di puntatori a
charè più conveniente di una matrice di caratteri per memorizzare stringhe di lunghezza diversa? -
Con
int i = 1; int *pi = &i;, sono ammissibilipi = i;e*pi = i;? Perché? -
Cosa fa l’istruzione
*pi++;e perché gcc avvisa “value computed is not used”? -
La dichiarazione
int *p;alloca memoria per un intero? E quanto occupap? Dipende dal tipo puntato? -
Dopo
*P = 3; *Q = 5; P = Q; *Q = 7;quanto vale*P? Perché? -
Con
int v[4]; int *p;perchép = vè ammissibile ep = &vev = pno? -
Perché
pc = p(daint *aconst int *) è ammesso ep = pcno?