Ripasso completo per la prima prova teorica intermedia di Programmazione 1: giovedì 5 novembre 2026, su carta, 50 minuti e 6 punti come la prova del 22/10/2024 (la durata del 2026 va controllata sull’avviso). Copre il programma dalla prima lezione ai puntatori compresi (deck 1.1-6.1), nell’ordine del corso; funzioni, passaggio dei parametri e ricorsione sono della seconda provetta e qui non ci sono. Il modello è la prima prova teorica del 22/10/2024, sei domande: SI/NO sui puntatori (1 punto), output esatto di tre cicli (1), figura con i cicli (1), somma fra basi (1), tavola di verità (0,5), algoritmo su un array di struct (1,5). Per questo le sezioni su tracing, puntatori, basi, tavole e struct sono le più lunghe; algoritmi e architettura restano compatte.
1Algoritmi
Teoria: Introduzione al corso e algoritmi · Esercizi: Introduzione al corso e algoritmi (esercizi)
1.1Da sapere
- Algoritmo: una sequenza precisa di operazioni, comprensibili da un esecutore, che definisce una sequenza finita di passi che portano alla realizzazione di un compito. Ogni parola esclude qualcosa: “precisa” esclude “sale quanto basta”, “finita” esclude “scrivi tutti i numeri pari”, “comprensibili” esclude i passi che l’esecutore non sa fare.
- Programma: un algoritmo scritto in un linguaggio di programmazione, cioè comprensibile da un calcolatore.
- Correttezza: l’algoritmo arriva alla soluzione senza errori. Efficienza: ci arriva con la minima quantità di risorse (tempo e memoria). Servono tutte e due.
- Tre strutture di controllo: sequenza, selezione (se/altrimenti), ripetizione (mentre).
- Top-down (raffinamenti successivi): un passo che l’esecutore non sa fare si dettaglia con un sotto-algoritmo.
- Ricerca sequenziale contro dicotomica: su schede ordinate la sequenziale fa fino a confronti, la dicotomica dimezza la parte da guardare a ogni confronto, quindi al massimo circa (con 1000 schede, 10, perché ). La dicotomica funziona solo su dati ordinati e ha due uscite: trovato, oppure parte vuota.
1.2Come si riconosce e come si fa
| Se vedi | Fai |
|---|---|
| ”scrivi un algoritmo in pseudocodice” | passi grossi numerati, poi raffina top-down quelli troppo grossi; solo sequenza, se, mentre |
| ”segui a mano l’algoritmo” | tabella con una colonna per variabile, una riga per passo eseguito |
| ”quanti confronti fa” | caso peggiore in funzione di : sequenziale , dicotomica il più piccolo con |
| “termina?“ | cerca nel ciclo cosa cambia a ogni giro e se la condizione prima o poi diventa falsa |
Tracing di un algoritmo:
- Una colonna per variabile, una per la condizione.
- Una riga per ogni passo nell’ordine in cui viene eseguito, non in cui è scritto.
- A ogni condizione scrivi il conto per esteso (“7 > 3 vero”).
- Controlla il risultato con un ragionamento diverso.
1.3Trappole
- Dimenticare il caso “non trovato” in una ricerca: senza, la dicotomica su un elemento assente non termina.
- Confondere correttezza ed efficienza: un algoritmo lento ma giusto è corretto.
- Applicare la dicotomica a dati non ordinati: scarta metà delle schede sulla base di un confronto che non dice niente.
- Seguire l’ordine in cui le righe sono scritte: un ciclo ripete le sue righe.
1.4Verifica
Domanda 1
Quale di questi procedimenti non è un algoritmo?
Risposta e spiegazione
c)Contare all’infinito i multipli di 3, stampandoli uno per uno
Un algoritmo è una sequenza finita di passi: “all’infinito” viola la finitezza, anche se ogni passo è preciso e comprensibile.
- a) è l’esempio delle slide: passi precisi per un esecutore che sa fare tabelline e sottrazioni.
- b) è la ricerca dicotomica: termina perché la parte rimasta si dimezza fino a trovare o a svuotarsi.
- d) guarda ogni carta una volta: 52 passi, poi finisce.
Domanda 2
Uno schedario ordinato ha 500 schede. Quanti confronti fa al massimo la ricerca dicotomica?
Risposta e spiegazione
c)9
Ogni confronto dimezza le schede rimaste: 500, 250, 125, 62, 31, 15, 7, 3, 1. Dopo 8 dimezzamenti resta una scheda, e il confronto con quella è il nono. Controllo con le potenze: .
- a) è il caso peggiore della ricerca sequenziale.
- b) è un solo dimezzamento.
- d) è circa : non c’entra.
Domanda 3
L’algoritmo calcola le radici di partendo da , ma con divide per zero. Che proprietà gli manca?
Risposta e spiegazione
b)La correttezza, perché su un dato ammesso non arriva alla soluzione
Correttezza vuol dire arrivare alla soluzione senza errori in nessun passo. Se l’algoritmo accetta in ingresso , , qualsiasi, con sbaglia: il caso limite va controllato dopo la lettura.
- a) l’efficienza riguarda le risorse, non gli errori.
- c) una divisione per zero non è un ciclo infinito.
- d) è proprio la dimenticanza che le note segnalano: i dati di ingresso vanno controllati.
Esercizio breve. Segui la ricerca dicotomica di 44 nello schedario 3 9 14 20 27 35 41 44 50 58 (posizioni da 0 a 9). Quanti confronti fa?
Soluzione
inizio0,fine9, centrale , scheda 27: , tengo la destra,inizio← 5.inizio5,fine9, centrale 7, scheda 44: trovato.
Due confronti. Controllo: la sequenziale guarda le posizioni da 0 a 7, cioè 8 confronti.
2Architettura del calcolatore
Teoria: Architettura hardware e software di un calcolatore · Esercizi: Architettura hardware e software di un calcolatore (esercizi)
2.1Da sapere
- Macchina di Von Neumann: CPU, memoria centrale, memoria di massa e periferiche collegate dal bus di sistema; dati e istruzioni nella stessa memoria.
- Registri della CPU: PC indirizzo della prossima istruzione; CIR l’istruzione corrente; AR indirizzo della cella da leggere o scrivere; DR la parola letta o da scrivere; SR i flag dell’ultima operazione; A, B operandi dell’ALU; CU coordina; il clock dà il ritmo.
- Ciclo fetch-decode-execute: fetch (PC in AR, READ, parola in DR, DR in CIR), decode (la CU interpreta il CIR), execute (segnali di controllo, ALU), poi il PC si incrementa.
- Memoria centrale: celle, ognuna con una parola, accesso diretto con l’indirizzo. Con indirizzi di bit si distinguono celle (non bit).
- RAM: ad accesso casuale (tempo indipendente dall’indirizzo) e volatile. ROM: a sola lettura, non volatile, contiene il programma di avvio; anche lei ad accesso casuale.
- Gerarchia: registri, cache (SRAM), memoria principale (DRAM), memoria di massa. Salendo più veloce e più piccola.
- Bus: collega due unità per volta, la CPU è master. Tre linee: indirizzi (dove), dati (cosa), controllo (che operazione e quando).
- Polling: la CPU continua a chiedere se il dato è pronto. Interrupt: la periferica avvisa la CPU interrompendola.
2.2Come si riconosce e come si fa
| Se vedi | Fai |
|---|---|
| ”descrivi il bus” o “differenza fra memorie” | definizione in una frase, poi parti o proprietà in elenco, poi un esempio |
| ”quante celle con bit” | celle; memoria totale per i bit della parola, diviso 8 per i byte |
| ”quanti bit di indirizzo per celle” | il più piccolo con |
| “come la CPU scrive una cella” | indirizzo in AR e sul bus indirizzi, dato in DR e sul bus dati, WRITE sul bus di controllo |
2.3Trappole
- Dire che con bit si indirizzano bit: sono celle (la slide lo scrive male).
- Confondere PC (un indirizzo) e CIR (un’istruzione).
- Dire che la ROM non è ad accesso casuale: lo è; la differenza con la RAM è volatile contro non volatile.
- Mettere la cache nella memoria di massa: sta fra registri e memoria principale.
- Confondere bit e byte (fattore 8) o 1000 e 1024.
2.4Verifica
Domanda 4
Cosa contiene il registro PC durante l’esecuzione di un’istruzione?
Risposta e spiegazione
b)L’indirizzo della prossima istruzione da eseguire
Program Counter: l’indirizzo della prossima istruzione. Nel fetch viene copiato in AR, e alla fine del ciclo si incrementa.
- a) è il CIR.
- c) i risultati dell’ALU finiscono nei registri; l’esito (zero, segno, riporto) nei flag dell’SR.
- d) è l’AR.
Domanda 5
Una macchina ha indirizzi di 20 bit e parole di 16 bit. Quanto è grande la memoria indirizzabile?
Risposta e spiegazione
a) celle, cioè 2 MB
Con 20 bit di indirizzo si distinguono celle, ognuna di 16 bit cioè 2 byte: byte MB (con 1 MB byte).
- b) è l’errore della slide: celle, non bit.
- c) moltiplica i bit invece di elevare.
- d) usa la parola al posto dell’indirizzo.
Domanda 6
Quale affermazione è vera?
Risposta e spiegazione
c)La cache è una memoria SRAM fra i registri e la memoria principale
La cache tiene pochi dati usati spesso, ed è SRAM perché deve essere veloce.
- a) è al contrario: la RAM perde il contenuto allo spegnimento, la ROM no.
- b) descrive l’interrupt; con il polling è la CPU che continua a chiedere.
- d) il dato va sul bus dati; sul bus indirizzi va dove scriverlo.
Esercizio breve. Una memoria ha 3000 celle da 32 bit. Quanti bit di indirizzo servono? Quanti byte occupa? Quante celle si indirizzerebbero al massimo con quegli indirizzi?
Soluzione
- Bit di indirizzo: il più piccolo con . , : .
- Una cella da 32 bit sono byte, quindi byte.
- Con 12 bit si distinguono celle: 1096 indirizzi restano inutilizzati.
Controllo: con 11 bit si arriverebbe solo all’indirizzo 2047, e la cella 2999 non avrebbe un indirizzo.
3Il linguaggio C
Teoria: Il Linguaggio C · Esercizi: Il Linguaggio C (esercizi)
3.1Da sapere
- Sintassi è la forma, semantica il significato. Un errore di sintassi lo ferma il compilatore; uno di semantica compila e dà un risultato sbagliato.
- Il C si compila: editor, preprocessore, compilatore, linker, loader. Si traduce tutto prima di eseguire.
- Identificatore valido: primo carattere lettera o
_, poi lettere, cifre o_; diverso dalle parole chiave; maiuscole e minuscole contano. - Una variabile ha nome, tipo, l-value (la cella, cioè dove) e r-value (il contenuto, cioè cosa). Una locale non inizializzata ha valore indeterminato.
- Assegnazione
x = espr: prima si calcola tutta la destra con i valori attuali, poi si scrive nella cella di sinistra. A sinistra serve un l-value. L’assegnazione ha un valore (quello assegnato) e associa da destra:a = b = 5èa = (b = 5). scanf("%d", &x)vuole l’indirizzo di dove scrivere e restituisce quanti dati ha letto;printfvuole la stringa di formato.
3.2Come si riconosce e come si fa
| Se vedi | Fai |
|---|---|
| ”quali identificatori sono validi” | tre controlli: primo carattere, caratteri ammessi, non è una parola chiave |
| ”errore di sintassi o di semantica?“ | non compila: sintassi; compila ma sbaglia: semantica |
| una sequenza di assegnazioni | tabella, una colonna per variabile, una riga per istruzione; si aggiorna solo la colonna a sinistra dell’= |
| più = in fila | si parte da quello più a destra |
3.3Trappole
scanf("%d", x)senza&: compila con un warning e scrive in una cella a caso.- Leggere
x = x + 1come un’equazione: è “prendi x, aggiungi 1, rimetti in x”. - Credere che
a = b;colleghi le variabili: copia il valore in quel momento. - Scambiare con
a = b; b = a;: il valore diaè perso, serve una variabile di appoggio.
3.4Verifica
Domanda 7
Quale identificatore è valido in C?
Risposta e spiegazione
a)_tot2
Comincia con _, poi lettere e cifre: tutte e tre le regole sono rispettate.
- b) comincia con una cifra.
- c) il trattino è il meno: per il C è
totmeno 2. - d) è una parola chiave.
Domanda 8
Cosa stampa il frammento?
int a = 1, b = 2, c = 3;
a = b = c + a;
printf("%d %d %d", a, b, c);
Risposta e spiegazione
d)4 4 3
Le assegnazioni associano da destra: a = (b = (c + a)). Prima c + a vale , si scrive in b; l’assegnazione vale 4 e si scrive in a. c non cambia. Output: 4 4 3.
- a) esegue solo l’assegnazione a
b. - c) esegue solo quella ad
a. - b) copia
csenza sommare.
Domanda 9
int x; scanf("%d", x); con gcc -Wall:
Risposta e spiegazione
b)compila con un warning, ed è un errore di semantica: scanf riceve un valore indeterminato invece di un indirizzo
La forma è corretta (sintassi), il significato no: scanf vuole dove scrivere. gcc avvisa format '%d' expects argument of type 'int *', but argument 2 has type 'int' (verificato) e a runtime il programma scrive in una cella a caso, di solito con segmentation fault.
- a) la sintassi è giusta, quindi compila.
- c) nessuna funzione aggiunge la
&. - d) il segno dell’input non c’entra.
Esercizio breve. Traccia il frammento e scrivi l’output.
int x = 5, y = 8, t;
t = x;
x = y;
y = t + x;
printf("x=%d y=%d\n", x, y);
Soluzione
| istruzione | x | y | t |
|---|---|---|---|
| dichiarazione | 5 | 8 | ? |
t = x; | 5 | 8 | 5 |
x = y; | 8 | 8 | 5 |
y = t + x; | 8 | 13 | 5 |
Output: x=8 y=13. Controllo: alla terza riga x vale già 8, quindi la destra è , non .
4Espressioni, operatori e costanti
Teoria: Espressioni, operatori e costanti · Esercizi: Espressioni, operatori e costanti (esercizi)
4.1Da sapere
- L’albero sintattico dice chi si applica a cosa; lo decidono precedenza, parentesi e associatività. Si valuta dal basso.
- Ordine delle precedenze, da chi lega di più: postfissi (
(),[],.,->,x++), unari (!,++x,-x,*,&,sizeof, cast),* / %,+ -, confronti< <= > >=, uguaglianze,&&,||,?:, assegnazioni. Gli unari,?:e le assegnazioni associano da destra, il resto da sinistra. - Fra due
int,/è divisione intera (tronca verso zero) e%è il resto. x op= esprvuol direx = x op (espr): la destra si calcola tutta prima.x++vale il valore prima e poi incrementa;++xincrementa e vale il valore dopo. Da soli come istruzione fanno la stessa cosa.- Lazy evaluation: in
A && BseAè falsoBnon si valuta; inA || BseAè veroBnon si valuta. I++dentroBallora non avvengono. 'a'è un carattere (vale 97),"a"una stringa di due celle. Cifre, maiuscole e minuscole hanno codici consecutivi:'0'48,'A'65,'a'97.- Modificare la stessa variabile due volte in un’espressione (
i = i++;) è comportamento indefinito.
4.2Come si riconosce e come si fa
| Se vedi | Fai |
|---|---|
| un’espressione con operatori misti | metti le parentesi implicite con la tabella, poi calcola dal basso |
/ o % | controlla i tipi: due interi, divisione intera |
x++ o ++x dentro un conto | scrivi due cose: il valore che entra nel conto e il nuovo valore di x |
&& o || con ++ a destra | valuta la sinistra; se decide già, la destra non si esegue |
c - '0', c - 'a' + 'A' | scrivi i codici ASCII e fai il conto |
4.3Trappole
x *= y + 1èx = x * (y + 1), nonx * y + 1.double m = 7 / 2;vale 3.0: la divisione è intera prima dell’assegnazione.3 < x < 10vale sempre 1:3 < xdà 0 o 1, che è minore di 10.'7' + 1è il carattere'8', non il numero 8.^non è la potenza.
4.4Verifica
Domanda 10
Quanto vale 17 % 5 * 2 + 7 / 2?
Risposta e spiegazione
b)7
%, * e / stanno nello stesso gruppo e associano da sinistra, poi il +: ((17 % 5) * 2) + (7 / 2). , , (divisione intera), . Verificato con printf.
- a) arrotonda a 4.
- c) usa la divisione reale fra due interi.
- d) si ferma a
17 % 5 * 2e dimentica+ 7 / 2.
Domanda 11
Cosa stampa il frammento?
int i = 3, j = 5, k;
k = i++ * 2 - --j;
printf("%d %d %d", i, j, k);
Risposta e spiegazione
c)4 4 2
i++ entra nel conto con il valore vecchio, 3, e poi i diventa 4. --j porta j a 4 ed entra nel conto con 4. . Output: 4 4 2.
- a) usa
igià incrementato: . - b) dimentica che
--jcambiaj. - d) dimentica che
i++cambiai.
Domanda 12
Cosa stampa il frammento?
int a = 0, b = 2, c;
c = a && b++;
c = c || ++b;
printf("%d %d", b, c);
Risposta e spiegazione
a)3 1
Prima riga: a è 0, quindi a && ... è falso senza guardare la destra; b++ non avviene, c vale 0. Seconda riga: c è 0, quindi || deve valutare la destra: ++b porta b a 3, che è diverso da zero, e c vale 1. Output: 3 1.
- b) esegue anche il
b++della prima riga, ignorando il cortocircuito. - c) salta anche il
++b, ma lì la sinistra non decide. - d) incrementa
bma sbaglia il valore logico:||con un operando diverso da zero vale 1.
Domanda 13
Con char c = 'd';, cosa stampa printf("%c%d", c - 'a' + 'A', c - 'a');?
Risposta e spiegazione
d)D3
c - 'a' è la posizione di d nell’alfabeto contando da 0: . Sommare 'A' dà , cioè 'D', stampato con %c. Output: D3.
- conta le lettere da 1.
- non converte in maiuscolo.
- stampa il primo valore con
%d, e il formato non ha spazi.
Esercizio breve. Con int x = 7;, quanto vale x dopo x %= 4 + 1;?
Soluzione
- Forma estesa con le parentesi:
x = x % (4 + 1), perché l’assegnazione ha la precedenza più bassa. - .
- .
x vale 2 (verificato). Controllo: la lettura sbagliata x % 4 + 1 darebbe .
5Algebra di Boole
Teoria: Algebra di Boole · Esercizi: Algebra di Boole (esercizi)
5.1Da sapere
- Valori: VERO = 1, FALSO = 0. NOT rovescia; AND è vero solo se entrambi sono veri; OR è vero se almeno uno è vero.
- Precedenza: NOT, poi AND, poi OR. In C:
!prima di&&, prima di||.A || B && CèA || (B && C), come . - Tavola di verità: con variabili righe.
- Due espressioni sono equivalenti se e solo se hanno la stessa tavola: per dire sì servono tutte le righe, per dire no ne basta una.
- De Morgan:
NOT (A AND B)=NOT A OR NOT B;NOT (A OR B)=NOT A AND NOT B. Il NOT entra e scambia AND e OR. - Distributive, in tutti e due i versi:
A AND (B OR C)=(A AND B) OR (A AND C)eA OR (B AND C)=(A OR B) AND (A OR C). - Implicazione
A ⇒ B: falsa solo con A vera e B falsa; equivale aNOT A OR B. EquivalenzaA ⇔ B: vera quando A e B hanno lo stesso valore. - Tautologia: sempre vera (
A OR NOT A). Contraddizione: sempre falsa (A AND NOT A). - In C ogni valore diverso da zero è vero;
!, confronti,&&e||restituiscono 0 o 1.!5vale 0.
5.2Come si riconosce e come si fa
| Se vedi | Fai |
|---|---|
| ”completa la tavola” | una colonna per sotto-espressione, dalle più interne; usa solo colonne già fatte |
| ”sono equivalenti?“ | tavola delle due; per il no basta una riga, scritta con i valori |
| ”nega la condizione” | De Morgan e confronti invertiti (< diventa >=) |
un’espressione C con !, confronti, && | parentesi implicite: unari, aritmetica, confronti, &&, || |
Compilare una tavola:
- Conta le variabili e scrivi righe in ordine (o nell’ordine dato dal testo, come all’esame).
- Metti le parentesi implicite con NOT > AND > OR.
- Una colonna per ogni sotto-espressione, dalla più interna.
- Controllo: un AND esterno ha pochi 1, un OR esterno pochi 0; due colonne legate da De Morgan sono una la negazione dell’altra.
5.3Trappole
- Negare
x > 3conx < 3: la negazione èx <= 3. - De Morgan senza scambiare:
!(A && B)non è!A && !B. !x > 2nega solox: si legge(!x) > 2.- “Fuori dall’intervallo” con
&&(x < 1 && x > 10): è una contraddizione, serve||. A ⇒ Bcon A falsa è vera.
5.4Verifica
Domanda 14
Con A falso, B vero, C vero, quanto vale A || B && !C?
Risposta e spiegazione
c)FALSO
Parentesi implicite: A || (B && (!C)). !C è falso, quindi B && !C è falso; A || falso con A falso è falso.
- a) guarda solo B.
- b) si ferma a
A || Be ignora!C; anche raggruppando da sinistra,(A || B) && !Cvale falso. - d) la precedenza è fissata dal linguaggio.
Domanda 15
Quale condizione è la negazione di x > 0 && y <= 5?
Risposta e spiegazione
b)x <= 0 || y > 5
De Morgan: !(P && Q) è !P || !Q. !(x > 0) è x <= 0, !(y <= 5) è y > 5. Controllo con , : l’originale è falsa ( no), la b è vera. Giusto, perché la negazione deve essere vera dove l’originale è falsa.
- a) non scambia
&&e lascia fuori . - c) non scambia
&&con||. - d) inverte male i confronti: perde e prende .
Domanda 16
A ⇒ B è falsa:
Risposta e spiegazione
c)solo quando A è vera e B è falsa
La promessa “se piove prendo l’ombrello” è rotta solo se piove e non lo prendo. È NOT A OR B, falsa solo con , .
- a) con A falsa l’implicazione è vera.
- b) con A falsa e B falsa è vera.
- d) descrive la negazione di
A ⇔ B: sbaglia la riga , .
Domanda 17
Con int x = 4;, cosa stampa printf("%d %d %d", 2 < x < 3, !x + 1, !(x + 1));?
Risposta e spiegazione
c)1 1 0
Primo: (2 < 4) < 3 è 1 < 3, cioè 1, anche se 4 non sta fra 2 e 3. Secondo: ! lega più di +, quindi (!4) + 1 è . Terzo: !(5) è 0. Output: 1 1 0 (gcc avvisa sul primo confronto con -Wall).
- a) legge
!xcome . - b) legge il primo come in matematica.
- d) inverte le ultime due.
Domanda 18
Quante righe ha la tavola di verità di un’espressione con 4 variabili?
Risposta e spiegazione
c)16
Ogni variabile raddoppia i casi: .
- a) è , tre variabili.
- b) confonde righe e variabili.
- d) è .
Esercizio breve (stile domanda 5). Completa la tavola.
| X | Y | X && !Y || !X && Y | !(X && Y) || X | !(!X || Y) |
|---|---|---|---|---|
| VERO | FALSO | |||
| FALSO | VERO | |||
| FALSO | FALSO | |||
| VERO | VERO |
Soluzione
| X | Y | X && !Y || !X && Y | !(X && Y) || X | !(!X || Y) |
|---|---|---|---|---|
| VERO | FALSO | VERO | VERO | VERO |
| FALSO | VERO | VERO | VERO | FALSO |
| FALSO | FALSO | FALSO | VERO | FALSO |
| VERO | VERO | FALSO | VERO | FALSO |
- Prima colonna:
(X && !Y) || (!X && Y), vera quando X e Y sono diversi (è lo XOR). - Seconda:
!(X && Y)è falsa solo con tutti e due veri, e lìXè vero: è una tautologia. - Terza: per De Morgan
!(!X || Y)èX && !Y, vera solo nella prima riga.
Controllo: la terza colonna è la negazione di !X || Y, che è falsa solo con X vero e Y falso; quindi la terza è vera solo in quella riga.
6Istruzioni condizionali
Teoria: Istruzioni condizionali · Esercizi: Istruzioni condizionali (esercizi)
6.1Da sapere
if (espr) istresegueistrsolo seesprè diversa da zero.if (espr) istr1 else istr2esegue una sola delle due; la condizione si valuta una volta.- Senza graffe il ramo è una istruzione, fino al primo
;. Un blocco{ ... }vale come una istruzione. - Dangling else: l’
elseva all’ultimoifsenzaelse, qualunque sia l’indentazione. e1 ? e2 : e3è un’espressione: valee2see1è vera, altrimentie3. Ha precedenza bassa, sotto l’aritmetica e i confronti.- In una catena
else ifci si ferma alla prima condizione vera.
6.2Come si riconosce e come si fa
| Se vedi | Fai |
|---|---|
if annidati senza graffe | riscrivi con le graffe: ogni else all’if più vicino senza else |
if (x = 0) | è un’assegnazione: x diventa 0, condizione falsa |
if (...); | ramo vuoto: quello che segue si esegue sempre |
?: in mezzo a un conto | tutta l’aritmetica e i confronti a sinistra del ? sono la condizione |
6.3Trappole
- Credere all’indentazione: conta solo la sintassi.
;fra}edelse: non compila.1 <= x <= 10al posto di1 <= x && x <= 10.- Catena
else ifcon la condizione più larga per prima: nasconde le altre.
6.4Verifica
Domanda 19
Cosa stampa il frammento?
int a = 0, b = 1;
if (a)
if (b) printf("X");
else printf("Y");
printf("Z");
Risposta e spiegazione
c)Z
L’else appartiene all’if (b), il più vicino, anche se è indentato sotto if (a). a è 0, quindi tutto l’if (b) ... else ... viene saltato. Resta printf("Z"). gcc con -Wall avvisa suggest explicit braces to avoid ambiguous 'else'.
- a) attacca l’
elseall’if (a), fidandosi dell’indentazione. - b) entra nell’
if (a)conafalso. - d) esegue entrambi i rami.
Domanda 20
Cosa stampa il frammento?
int x = 5;
if (x = 0) printf("A"); else printf("B");
printf("%d", x);
Risposta e spiegazione
b)B0
x = 0 assegna 0 a x e vale 0: condizione falsa, ramo else. Poi stampa il nuovo x, 0. Output: B0.
- a) legge = come e lascia
xa 5; anche così5 </mark> 0sarebbe falso. - c) non vede l’assegnazione.
- d) prende vera una condizione che vale 0.
Domanda 21
Con int a = 3, b = 7;, cosa stampa printf("%d", 10 + a > b ? a : b);?
Risposta e spiegazione
d)3
?: ha precedenza più bassa di + e >: la condizione è (10 + a) > b, cioè , vera. Il valore è a, 3.
- è
10 + a, la parte sinistra della condizione. - prende il ramo falso, ma è vero.
- è
10 + (a > b ? a : b): le parentesi messe da chi legge, non dal C.
Esercizio breve. Cosa stampa questo frammento con int x = -2;?
if (x > 0);
printf("pos");
printf("_%d", x);
Soluzione
if (x > 0);ha come ramo l’istruzione vuota;.printf("pos");non è nel ramo, nonostante l’indentazione: si esegue sempre.- Poi
_-2.
Output: pos_-2 (verificato; gcc con -Wextra avvisa suggest braces around empty body). Controllo: con le graffe if (x > 0) { printf("pos"); } lo stesso frammento stamperebbe solo _-2.
7Ciclo while
Teoria: Ciclo while ed esempi · Esercizi: Ciclo while ed esempi (esercizi)
7.1Da sapere
while (espr) istr: si valuta la condizione; se è vera si esegue il corpo e si torna a valutare; se è falsa si esce. Il corpo può girare zero volte.- Termina solo se il corpo cambia qualcosa che rende falsa la condizione; altrimenti è un ciclo infinito.
- Contatore (
n++) e accumulatore (s += x) si inizializzano prima del ciclo: 0 per somme e conteggi, 1 per prodotti, il primo elemento per massimo e minimo. - Sentinella: un valore speciale che segnala la fine dei dati. Si legge prima del ciclo e si rilegge in fondo al corpo, così non viene elaborato come dato.
- Euclide per sottrazioni: finché i due numeri sono diversi si sottrae il minore dal maggiore; quando sono uguali, quello è il MCD.
- Con
k--nella condizione si confronta il valore vecchio, e il decremento avviene anche nel test che fa uscire.
7.2Come si riconosce e come si fa
| Se vedi | Fai |
|---|---|
| ”scrivi l’output esatto” di un ciclo | tabella: una riga per giro, colonne per variabili, condizione e output |
condizione con i++ o k-- | confronta il vecchio valore, poi aggiorna, anche all’uscita |
n % 10 e n /= 10 | estrazione delle cifre da destra |
| cicli annidati | il ciclo interno riparte da capo a ogni giro esterno; somma i giri |
| ”quante volte gira” | prova primo e ultimo giro; l’uscita è il primo valore che rende falsa la condizione |
Tracciare un ciclo:
- Riga iniziale con i valori prima del ciclo.
- Per ogni giro: condizione con i valori correnti, poi il corpo istruzione per istruzione.
- All’uscita: numero di giri, valori finali, output carattere per carattere.
7.3Trappole
- Corpo di più istruzioni senza graffe: solo la prima è nel ciclo.
while (cond);con il punto e virgola: corpo vuoto, spesso ciclo infinito.- Credere che si esca con la variabile uguale al limite: con
i < 50ei *= 3si esce con 81. - Accumulatore non inizializzato, o inizializzato dentro il ciclo.
7.4Verifica
Domanda 22
Cosa stampa il frammento?
int i = 1, n = 0;
while (i < 50) {
i *= 3;
n++;
}
printf("%d %d", i, n);
Risposta e spiegazione
b)81 4
i vale 1, 3, 9, 27, 81. I test veri sono con 1, 3, 9, 27: quattro giri. Con 81 il test è falso. Output: 81 4.
- a) si ferma un giro prima.
- c) crede che si esca con il limite.
- d) conta anche il test che fa uscire.
Domanda 23
Cosa stampa il frammento?
int k = 4;
while (k--)
printf("%d_", k);
printf("%d", k);
Risposta e spiegazione
d)3_2_1_0_-1
Ogni test confronta il valore vecchio di k e poi lo decrementa: test con 4 (vero, k diventa 3, stampa 3_), 3, 2, 1 (vero, stampa 0_), poi 0 (falso, ma k diventa ). Output: 3_2_1_0_-1.
- stampa il valore prima del decremento.
- dimentica che anche il test che fa uscire decrementa.
- salta il giro con il test a 1.
Domanda 24
Cosa stampa il frammento?
int n = 4071, s = 0;
while (n > 0) {
printf("%d_", n % 10);
s += n % 10;
n /= 10;
}
printf("%d", s);
Risposta e spiegazione
a)1_7_0_4_12
% 10 dà l’ultima cifra, / 10 la toglie: si stampa da destra. n passa per 4071, 407, 40, 4, poi 0. Cifre 1, 7, 0, 4, somma 12.
- b) legge le cifre da sinistra.
- c) salta lo zero: anche
40 % 10è una cifra. - d) stampa
nall’uscita invece dis.
Domanda 25
Quanto vale c alla fine?
int i = 0, j, c = 0;
while (i < 4) {
j = i;
while (j < 4) {
c++;
j++;
}
i++;
}
Risposta e spiegazione
d)10
Il ciclo interno parte da j = i: per i uguale a 0, 1, 2, 3 gira 4, 3, 2, 1 volte. . Alla fine i e j valgono 4 (verificato: 10 4 4).
- è , come se
jpartisse sempre da 0. - conta solo il primo giro esterno.
- è : perde il giro con
ia 0.
Esercizio breve. Traccia Euclide per sottrazioni con , : quanti giri, che MCD?
Soluzione
| giro | confronto | sottrazione | m | n |
|---|---|---|---|---|
| inizio | 28 | 12 | ||
| 1 | m = 28 - 12 | 16 | 12 | |
| 2 | m = 16 - 12 | 4 | 12 | |
| 3 | n = 12 - 4 | 4 | 8 | |
| 4 | n = 8 - 4 | 4 | 4 | |
| , esce |
4 giri, MCD 4 (verificato con il programma). Controllo: 4 divide 28 e 12, e 28/4 = 7, 12/4 = 3 non hanno divisori comuni.
8Input e output di caratteri
Teoria: Input e output di caratteri · Esercizi: Input e output di caratteri (esercizi)
8.1Da sapere
getchar()legge il prossimo carattere dallo standard input e lo restituisce; ogni chiamata consuma un carattere.putchar(c)stampac.EOFè una costanteintdistdio.h(vale con gcc) chegetcharrestituisce quando l’input è finito.- La variabile che riceve
getcharèint, nonchar: deve contenere i 256 valori di un byte più EOF. - Il ciclo tipo:
while ((c = getchar()) != EOF). Le parentesi servono perché != lega più dell’assegnazione. - Spazi e
'\n'sono caratteri come gli altri. La tastiera passa i caratteri al programma a riga completata (buffer).
8.2Come si riconosce e come si fa
| Se vedi | Fai |
|---|---|
| ”cosa stampa con input …“ | scrivi l’input carattere per carattere, \n compreso, una riga di tabella per carattere |
| contare righe, cifre, lettere | un contatore per categoria, un if per categoria nel ciclo di lettura |
getchar() anche nel corpo | ogni chiamata consuma un carattere in più: contali |
8.3Trappole
c = getchar() != EOFsenza parentesi:cvale 1 o 0.char cper il risultato digetchar.- Dimenticare il
'\n'finale nei conteggi. somma += csenza- '0': somma i codici ASCII.
8.4Verifica
Domanda 26
Perché la variabile che riceve getchar() si dichiara int?
Risposta e spiegazione
d)Perché deve poter contenere ogni carattere e in più il valore EOF, che non è un carattere
Un char ha 256 valori, tutti occupati dai caratteri possibili; EOF deve essere un valore in più, e serve un tipo più grande.
- a)
getcharrestituisce qualunque carattere. - c)
putcharaccetta anche unchar, che si converte. - b)
intoccupa 4 byte,char1.
Domanda 27
Cosa contiene c dopo c = getchar() != EOF; se l’input è la lettera k?
Risposta e spiegazione
b)1
!= lega più di =: si legge c = (getchar() != EOF). Il carattere letto non è EOF, il confronto vale 1, e c riceve 1. Il carattere è perso (verificato con printf 'k' | ./a.out: stampa 1).
- a) sarebbe con le parentesi
(c = getchar()) != EOF. - c) sarebbe a input finito.
- d) il confronto vale 0 o 1, mai EOF.
Domanda 28
Il programma seguente riceve in input ab c seguito da a capo. Cosa stampa?
int c, n = 0;
while ((c = getchar()) != EOF)
if (c != ' ')
n++;
printf("%d", n);
Risposta e spiegazione
d)4
I caratteri sono a, b, spazio, c, \n. Lo spazio non si conta, l’a capo sì: 4 (verificato con printf 'ab c\n' | ./a.out).
- dimentica che
'\n'è un carattere. - conta anche lo spazio.
- conta solo le lettere prima dello spazio.
Esercizio breve. Cosa stampa questo programma con input r2-d2 ok seguito da a capo?
int c;
while ((c = getchar()) != EOF) {
if (c >= 'a' && c <= 'z')
putchar(c - 'a' + 'A');
else if (c >= '0' && c <= '9')
putchar('#');
else
putchar(c);
}
Soluzione
rminuscola: diventaR.2cifra:#.-nessuna categoria: resta-.ddiventaD,2diventa#.- spazio resta spazio;
o,kdiventanoO,K;\nresta un a capo.
Output: R#-D# OK e a capo (verificato). Controllo: 9 caratteri in ingresso (a capo compreso), 9 in uscita, perché ogni giro fa esattamente una putchar.
9Cicli for e do-while
Teoria: Cicli for e do-while · Esercizi: Cicli for e do-while (esercizi) · Prova 2024: domande 2 e 3
9.1Da sapere
for (espr1; espr2; espr3) corpo:espr1una volta all’inizio;espr2prima di ogni giro;espr3dopo ogni giro. Equivale aespr1; while (espr2) { corpo espr3; }, tranne con uncontinuenel corpo.do { corpo } while (espr);: prima il corpo, poi la condizione. Gira almeno una volta. Il;finale è obbligatorio.break: esce subito dal ciclo (o dalloswitch) che lo contiene direttamente;espr3non si esegue.continue: salta il resto del corpo; nelforva aespr3e poi alla condizione, nelwhiledirettamente alla condizione. Non vale per loswitch.- Dopo
for (i = 0; i < n; i++)la variabile vale .
Teorema di Böhm-Jacopini.
- Ipotesi: un algoritmo qualsiasi espresso con un diagramma di flusso.
- Tesi: lo si può codificare usando solo sequenza, selezione (
if-else) e ciclo (while): queste tre strutture sono complete.
A cosa serve: for, do-while e switch non aggiungono potenza, solo comodità; ognuno si riscrive con while e if-else.
9.2Come si riconosce e come si fa
| Se vedi | Fai |
|---|---|
for con i++ anche nel printf | due colonne: i dopo il corpo e i dopo espr3 |
espr3 che non è i++ (i += i, i /= 2) | elenca i valori uno per uno fino al primo che rende falsa la condizione |
do-while | il primo giro avviene comunque, poi è un while |
break e continue | break esce senza espr3; continue fa espr3 |
| ”stampa la figura, obbligatorio usare i cicli” | griglia con righe e colonne , condizione o conteggio in funzione di , lato in una #define |
Stampare una figura:
- Disegna la figura su una griglia e numera righe e colonne da 0.
- Se ogni riga è fatta di pezzi contigui, conta quanti caratteri di ogni tipo in funzione di ; se i pezzi sono sparsi, scrivi la condizione su .
- Verifica la formula sulla prima e sull’ultima riga.
- Ciclo esterno sulle righe, interno sulle colonne,
printf("\n")dopo il ciclo interno. - Il lato in una
#define, mai i numeri del disegno nei cicli.
9.3Trappole
for (i = 0; i < 3; i++);con il punto e virgola: il blocco dopo si esegue una volta, conia 3.i++e++iinespr3sono identici; contano solo dove il valore si usa.do-whilequando zero giri è possibile.breakin un ciclo annidato esce solo da quello interno.- Figura con una
printfper riga: se il testo chiede i cicli vale zero.
9.4Verifica
Domanda 29
Cosa stampa il frammento?
int i;
for (i = 2; i < 20; i += i)
printf("%d_", i);
printf("%d", i);
Risposta e spiegazione
a)2_4_8_16_32
i += i raddoppia: 2, 4, 8, 16 superano il test; 32 no. L’ultima printf stampa il valore di uscita, 32.
- b) legge
i += icomei += 2. - c) crede che si esca con l’ultimo valore stampato.
- d) dimentica la
printfdopo il ciclo.
Domanda 30
Cosa stampa il frammento?
int i;
for (i = 5; i > 0; i -= 2)
printf("%d_", i--);
printf("%d", i);
Risposta e spiegazione
b)5_2_-1
i scende due volte per giro: i-- nella printf (stampa il vecchio) e i -= 2 in espr3.
| giro | i al test | stampa | dopo i-- | dopo i -= 2 |
|---|---|---|---|---|
| 1 | 5 | 5_ | 4 | 2 |
| 2 | 2 | 2_ | 1 | |
| fine | esce |
- a) ignora il
i--nellaprintf. - c) stampa il valore dopo il decremento, come
--i. - d) sbaglia l’ultimo
espr3: .
Domanda 31
Cosa stampa il frammento?
int i = 10;
do {
printf("%d_", i);
i += 5;
} while (i < 10);
printf("%d", i);
Risposta e spiegazione
c)10_15
Il do-while esegue il corpo prima di guardare la condizione: stampa 10_, i diventa 15, è falso, si esce. Poi 15.
- a) tratta il ciclo come un
while, che qui non girerebbe mai: resta solo laprintffinale con 10. - b) come a), e in più dimentica la
printfdopo il ciclo. - d) fa un secondo giro con il test falso.
Domanda 32
Cosa stampa il frammento?
int i;
for (i = 1; i <= 10; i++) {
if (i % 4 == 0) break;
if (i % 2) continue;
printf("%d_", i);
}
printf("%d", i);
Risposta e spiegazione
b)2_4
: dispari, continue. : stampa 2_. : continue. : , break senza eseguire i++. Poi stampa 4.
- a) ignora il
break. - c) esegue
espr3anche dopo ilbreak. - d) scambia il significato di
i % 2: vale 1 per i dispari, quindi ilcontinuescatta sui dispari.
Domanda 33
Quanto vale c alla fine?
int i, j, c = 0;
for (i = 0; i < 5; i++)
for (j = i; j < 5; j += 2)
c++;
Risposta e spiegazione
c)9
Per ogni i il ciclo interno visita j = i, i + 2, ... sotto 5:
i | valori di j | giri |
|---|---|---|
| 0 | 0, 2, 4 | 3 |
| 1 | 1, 3 | 2 |
| 2 | 2, 4 | 2 |
| 3 | 3 | 1 |
| 4 | 4 | 1 |
(verificato).
- a) è .
- b) è , con passo 1.
- d) sbaglia i giri con
ipari.
Esercizio breve (stile domanda 3). Scrivi un programma che stampi la figura seguente con righe in una #define. Obbligatorio usare i cicli.
0
1 0
0 1 0
1 0 1 0
Soluzione
Righe e colonne da 0. La riga ha elementi, e la cella vale 0 quando è pari, 1 quando è dispari: il valore è .
#include <stdio.h>
#define N 4
int main(void)
{
int r;
int c;
for (r = 0; r < N; r++) {
for (c = 0; c <= r; c++)
printf("%d ", (r + c) % 2);
printf("\n");
}
return 0;
}
Controllo sulla prima e sull’ultima riga: , solo , ; , da 0 a 3, valori 1, 0, 1, 0. Output verificato, uguale al disegno (ogni riga finisce con uno spazio prima dell’a capo).
10Switch
Teoria: Switch · Esercizi: Switch (esercizi)
10.1Da sapere
switch (espressione intera): si valuta una volta, si entra dalcasecon lo stesso valore (ovunque sia scritto) o daldefault; senza nessuno dei due non succede niente.- Da lì si esegue tutto verso il basso fino al primo
breako alla fine: icasesono etichette, non confini (fall-through). - L’espressione è intera (
int,char); icasesono costanti intere, ognuna una volta sola. Nientefloat, stringhe, variabili o intervalli. breakdentro unoswitchesce dalloswitch, non dal ciclo che lo contiene;continueinvece agisce sul ciclo.
10.2Come si riconosce e come si fa
| Se vedi | Fai |
|---|---|
switch con break mancanti | trova l’etichetta di ingresso, esegui verso il basso fino al primo break |
default in mezzo | ci si entra solo se nessun case corrisponde, poi si cade nei case sotto |
switch su un carattere | case '1': vale 49, case 1: vale 1 |
switch in un ciclo | una riga per giro: valore, etichetta, blocchi eseguiti |
10.3Trappole
- Credere che i
casesi provino in ordine numerico o chedefaultdebba stare in fondo. case 1:per il carattere'1'.breaknelloswitchcredendo che esca dal ciclo.
10.4Verifica
Domanda 34
Cosa stampa il frammento?
int x = 9;
switch (x % 3) {
case 0: printf("A");
default: printf("D");
case 1: printf("B"); break;
case 2: printf("C");
}
Risposta e spiegazione
c)ADB
: si entra da case 0. Senza break si cade nel default e nel case 1, il cui break ferma tutto. Output: ADB.
- a) tratta ogni
casecome se avesse il suobreak. - b) si ferma all’etichetta
case 1, ma le etichette non fermano niente. - d) ignora il
break.
Domanda 35
Cosa stampa il frammento?
int i;
for (i = 0; i < 4; i++) {
switch (i) {
case 1: continue;
case 2: break;
default: printf("%d_", i);
}
printf("x");
}
Risposta e spiegazione
a)0_xx3_x
i | ingresso | cosa succede | stampa |
|---|---|---|---|
| 0 | default | stampa, poi esce dallo switch | 0_x |
| 1 | case 1 | continue: salta anche la printf("x") | niente |
| 2 | case 2 | break esce solo dallo switch | x |
| 3 | default | come per 0 | 3_x |
- b) fa uscire il
breakanche dallaprintf("x"). - c) fa uscire il
breakdal ciclo. - d) perde l’ultima
x.
Domanda 36
Con char c = '2';, quale ramo si esegue?
switch (c) {
case 2: printf("due"); break;
case '2': printf("carattere"); break;
default: printf("altro");
}
Risposta e spiegazione
b)case '2'
'2' vale 50, 2 vale 2: sono valori diversi, quindi compila, e c vale 50. Output: carattere (verificato).
- a) confonde carattere e numero.
- c) c’è un
caseuguale. - d) i valori 2 e 50 sono distinti.
Esercizio breve. Scrivi l’output esatto.
char s[] = "ab1?";
int i, v = 0, c = 0, a = 0;
for (i = 0; s[i] != '\0'; i++) {
switch (s[i]) {
case 'a': v++;
case 'b': c++; break;
case '1': a++; break;
default: a += 10;
}
}
printf("%d %d %d", v, c, a);
Soluzione
s[i] | ingresso | eseguito | v | c | a |
|---|---|---|---|---|---|
a | case 'a' | v++, poi cade in case 'b': c++, break | 1 | 1 | 0 |
b | case 'b' | c++, break | 1 | 2 | 0 |
1 | case '1' | a++, break (il carattere '1', non il numero) | 1 | 2 | 1 |
? | default | a += 10 | 1 | 2 | 11 |
Output: 1 2 11 (verificato; gcc con -Wextra avvisa del fall-through). Controllo: v + c conta le lettere più la a contata due volte, .
11Array
Teoria: Array · Esercizi: Array (esercizi)
11.1Da sapere
- Array: una sequenza di celle di memoria consecutive e omogenee, con un identificatore unico; a ogni cella si accede con un indice intero . Con
int a[N]gli indici vanno da 0 a . - La dimensione è fissa e si scrive con una
#define.int n = 5; int v[n];è un VLA, non un array statico. - Inizializzazione:
{5, 2, -5}; con meno valori delle celle le restanti valgono 0 ({0}azzera tutto); più valori delle celle è un errore. - Un indice fuori range non viene controllato: è comportamento indefinito.
- Niente operazioni sull’array intero: non si assegna, non si confronta, non si stampa con un
printfsolo. Si lavora cella per cella.
11.2Come si riconosce e come si fa
| Se vedi | Fai |
|---|---|
a[espr] con indici calcolati | calcola prima l’indice (con i ++), controlla che stia fra 0 e , poi apri la cella |
a[a[i]] | dall’interno verso l’esterno |
| ”massimo e posizione” | indice del massimo che parte da 0, ciclo da 1; > tiene il primo, >= l’ultimo |
| ”quante volte compare ogni valore” | array di contatori azzerato, conta[valore]++ |
| ”cerca x” | while (i < N && v[i] != x) i++; trovato se |
| “sposta a destra” | ciclo dal fondo: v[i] = v[i - 1] |
11.3Trappole
i <= Nnella condizione: leggea[N], fuori.- Spostare a destra partendo da sinistra: ricopia lo stesso valore in tutte le celle.
- Ricerca con le condizioni scambiate (
v[i] != x && i < N): leggev[N]prima del controllo. - Massimo inizializzato a 0: sbaglia con tutti negativi.
11.4Verifica
Domanda 37
Dopo int a[5] = {3};, quanto valgono a[0] e a[4]?
Risposta e spiegazione
c)3 e 0
Inizializzazione parziale: il primo valore va in a[0], le celle senza valore valgono 0. Output di printf("%d %d", a[0], a[4]): 3 0.
- a)
{3}non riempie tutto di 3. - b) con l’inizializzazione fra graffe le celle restanti sono azzerate.
- d) meno valori delle celle è lecito.
Domanda 38
Cosa stampa il frammento?
int v[5] = {1, 2, 3, 4, 5};
int i;
for (i = 1; i < 5; i++)
v[i] = v[i - 1];
for (i = 0; i < 5; i++)
printf("%d_", v[i]);
Risposta e spiegazione
d)1_1_1_1_1_
Il ciclo va da sinistra: v[1] = v[0] mette 1, poi v[2] = v[1] copia l’1 appena scritto, e così via. Per ottenere lo spostamento a destra bisogna partire dal fondo.
- è il risultato del ciclo dal fondo.
- è lo spostamento a sinistra.
- crede che il ciclo non cambi niente.
Domanda 39
Cosa stampa il frammento?
int d[8] = {1, 3, 1, 0, 2, 1, 3, 1};
int conta[4] = {0};
int i;
for (i = 0; i < 8; i++)
conta[d[i]]++;
for (i = 0; i < 4; i++)
printf("%d_", conta[i]);
Risposta e spiegazione
b)1_4_1_2_
Ogni valore di d è un indice di conta: lo 0 compare una volta, l’1 quattro (posizioni 0, 2, 5, 7), il 2 una, il 3 due. Somma , come gli elementi.
- a) stampa i primi elementi di
d. - c) stampa gli indici.
- d) scambia i contatori.
Domanda 40
Con int v[5] = {4, 9, 2, 9, 1};, quali posizioni trovano i due cicli?
for (i = 1; i < 5; i++) {
if (v[i] > v[p1]) p1 = i;
if (v[i] >= v[p2]) p2 = i;
}
(con p1 e p2 che partono da 0)
Risposta e spiegazione
a)p1 1, p2 3
Con > l’indice cambia solo per un valore strettamente maggiore, quindi resta sul primo 9 (posizione 1). Con >= passa anche sul secondo 9: posizione 3 (verificato: 1 3).
- b) scambia i due operatori.
- c) e d) ignorano la differenza fra
>e>=sui valori uguali.
Esercizio breve. Con int v[6] = {8, 3, 5, 3, 7, 1};, quanto vale i dopo i = 0; while (i < 6 && v[i] != x) i++; con ? E con ?
Soluzione
- :
v[0]è 8, avanza;v[1]è 3, il ciclo si ferma.ivale 1: trova la prima occorrenza. - : nessuna cella vale 4, il ciclo arriva a e si ferma per
i < 6falso. Grazie al cortocircuitov[6]non viene mai letto.
Risultati: 1 e 6 (verificato). Controllo: “trovato” è , vero solo nel primo caso.
12Matrici
Teoria: Matrici e array multidimensionali · Esercizi: Matrici e array multidimensionali (esercizi)
12.1Da sapere
int a[R][C]: righe e colonne,a[i][j]è riga , colonna , indici da 0. Valore iniziale indefinito.- In memoria la matrice è lineare, per righe:
a[i][j]è la cella numero contando daa[0][0]. Per questo il compilatore deve sapere , e nell’inizializzazione si può omettere solo la prima dimensione. - Inizializzazione:
{{1, 2}, {3, 4}}; le celle senza valore valgono 0. - Per le quadrate: diagonale principale , secondaria , triangolo superiore , bordo o o o .
12.2Come si riconosce e come si fa
| Se vedi | Fai |
|---|---|
”posizione lineare di a[i][j]” | ; il numero di righe non serve |
un tracing con m[espr1][espr2] | griglia con indici di riga e colonna, calcola i due indici prima di scrivere |
| diagonali | un ciclo solo: m[i][i] e m[i][N - 1 - i] |
| somma per righe o colonne | array di accumulatori azzerato, riempito nella stessa scansione |
| trasposta sul posto | scambia m[i][j] e m[j][i] solo per |
12.3Trappole
a[i, j]al posto dia[i][j]: la virgola è un operatore.- Trasporre sul posto con
jda 0: ogni scambio avviene due volte e la matrice non cambia. - Diagonale secondaria scritta
i == N - j: è spostata di una colonna. printf("\n")dentro il ciclo interno.
12.4Verifica
Domanda 41
Con int m[5][7];, in che posizione lineare (contando da 0) sta m[3][2]?
Risposta e spiegazione
b)23
Prima di m[3][2] ci sono 3 righe complete da 7 elementi e 2 elementi della riga 3: .
- a) usa il numero di righe, .
- c) dimentica le 2 colonne.
- d) affianca le cifre di riga e colonna: non è un conto.
Domanda 42
Cosa stampa il frammento?
int m[3][3];
int i, j;
for (i = 0; i < 3; i++)
for (j = 0; j < 3; j++)
m[i][j] = 3 * i + j;
for (i = 0; i < 3; i++)
printf("%d_", m[i][2 - i]);
Risposta e spiegazione
d)2_4_6_
La matrice ha righe 0 1 2, 3 4 5, 6 7 8. m[i][2 - i] è la diagonale secondaria letta dall’alto: m[0][2] 2, m[1][1] 4, m[2][0] 6.
- è la diagonale principale.
- è la secondaria letta dal basso.
- è l’ultima colonna.
Domanda 43
Cosa stampa il frammento?
int m[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int i, j, t;
for (i = 0; i < 3; i++)
for (j = 0; j < 3; j++) {
t = m[i][j];
m[i][j] = m[j][i];
m[j][i] = t;
}
printf("%d %d", m[0][1], m[1][0]);
Risposta e spiegazione
b)2 4
Con j da 0 ogni coppia fuori diagonale si scambia due volte: (0,1) con (1,0) quando , , e di nuovo quando , . La matrice torna com’era (verificato: 2 4). Per trasporre serve j da i + 1.
- a) è la trasposta che ci si aspetterebbe.
- c) e d) sono scambi fatti senza variabile di appoggio.
Esercizio breve. Con int m[2][3] = {{4, 1, 6}, {2, 8, 3}};, quanto valgono le somme per colonna? E quanto vale la somma di tutti gli elementi di int k[3][3] = {{1}, {2, 3}};?
Soluzione
- Colonne di
m: , , . Con un ciclocol[j] += m[i][j]esce6 9 9(verificato). k: la riga 0 è1 0 0, la riga 12 3 0, la riga 2 tutta a 0. Somma ;k[1][1]vale 3 ek[0][1]vale 0 (verificato).
Controllo per m: la somma delle colonne, , è uguale alla somma delle righe, .
13Stringhe
Teoria: Stringhe · Esercizi: Stringhe (esercizi)
13.1Da sapere
- Una stringa in C è un array di
charin cui dopo l’ultimo carattere utile c’è il carattere nullo'\0'(codice 0). Per caratteri servono celle. - Lunghezza: i caratteri prima del primo
'\0'. Dimensione (sizeof): le celle dell’array. char s[] = "Ciao";riserva 5 celle e mette il terminatore da solo.printf("%s", s)stampa fino al primo'\0'.scanf("%19s", s)senza&(il nome dell’array è già un indirizzo) e si ferma al primo spazio.s = "altro";fuori dalla dichiarazione non compila;s1 == s2confronta indirizzi. Si lavora carattere per carattere.
13.2Come si riconosce e come si fa
| Se vedi | Fai |
|---|---|
| ”lunghezza” | while (s[i] != '\0') i++; il risultato è l’indice del terminatore |
| una stringa modificata | caselle con indici e terminatore; dopo ogni modifica cerca il primo '\0' |
| maiuscole, cifre | controlla la categoria (c >= 'a' && c <= 'z'), poi c - 'a' + 'A' o c - '0' |
| copia o concatenazione | copia fino al terminatore, poi scrivi '\0' |
| palindromo, inversione | due indici, sx da 0 e dx da lunghezza meno 1, finché sx < dx |
13.3Trappole
- Dimenticare la cella del terminatore, o non scriverlo dopo una copia.
scanf("%s", &nome)o senza larghezza massima.dxche parte dalla lunghezza invece che dalla lunghezza meno 1.'\0'scritto'0'(il carattere cifra, 48).
13.4Verifica
Domanda 44
Con char s[] = "Prog 1";, quanto valgono sizeof(s) e la lunghezza della stringa?
Risposta e spiegazione
d)7 e 6
La stringa ha 6 caratteri (lo spazio conta), l’array 7 celle con il terminatore (verificato: 7 6).
- a) dimentica la cella del terminatore.
- c) conta il terminatore nella lunghezza.
- b) non conta lo spazio.
Domanda 45
Con lo stesso s, cosa stampa s[4] = '\0'; printf("[%s]", s);?
Risposta e spiegazione
b)[Prog]
s[4] era lo spazio: diventa il terminatore, e %s si ferma lì. Le celle dopo (1 e il vecchio '\0') restano in memoria ma non si vedono.
- a) ignora la modifica.
- c) crede che il
'\0'venga saltato. - d) sostituisce la cella sbagliata.
Domanda 46
Cosa stampa il frammento?
char s[] = "a1b2c3";
int i = 0, n = 0;
while (s[i] != '\0') {
if (s[i] >= '0' && s[i] <= '9')
n += s[i] - '0';
else
s[i] = s[i] - 'a' + 'A';
i++;
}
printf("%s %d", s, n);
Risposta e spiegazione
a)A1B2C3 6
Le lettere diventano maiuscole al loro posto, le cifre restano e si sommano come valori: .
- b) dimentica che il ramo
elsemodificas. - c) somma i codici ASCII, : manca il
- '0'. - d) crede che le cifre vengano tolte dalla stringa.
Domanda 47
Il programma esegue scanf("%19s", nome) con char nome[20] e l’utente scrive Mario Rossi. Cosa contiene nome?
Risposta e spiegazione
b)Mario
%s legge fino al primo spazio bianco (verificato: [Mario]). Rossi resta nel buffer per la lettura successiva.
- a)
%snon legge frasi. - c) prende la seconda parola.
- d)
nomeè un array, quindi già un indirizzo: la&non ci va.
Esercizio breve. Traccia il controllo di palindromo su char s[] = "radar";: valori finali di sx e dx e risultato.
int sx = 0, dx = 0;
while (s[dx] != '\0')
dx++;
dx--;
while (sx < dx && s[sx] == s[dx]) {
sx++;
dx--;
}
Soluzione
- Il primo ciclo porta
dxa 5 (il terminatore), poidx--lo porta a 4, l’ultima lettera. sx0,dx4:reruguali, diventano 1 e 3.aeauguali, diventano 2 e 2.- falso: esce.
Fine con sx 2 e dx 2, e vuol dire palindroma (verificato: palindroma 2 2). Controllo: con "radio" il ciclo si ferma su a contro i con .
14Rappresentazione dell’informazione
Teoria: Rappresentazione dell’informazione · Esercizi: Rappresentazione dell’informazione (esercizi) · Prova 2024: domanda 4
14.1Da sapere
- Sistema posizionale in base : cifre da 0 a ; la cifra in posizione da destra (da 0) vale cifra per . In base 16, A=10 … F=15.
- Da base a 10: pesi. Da 10 a base : algoritmo dei resti, letti dall’ultimo al primo. Fra 2, 8 e 16: gruppi di 3 o 4 bit da destra.
- Con bit senza segno: da 0 a . Gli interi del calcolatore hanno sempre un massimo; superarlo è overflow. Per valori servono bit con .
- Modulo e segno: primo bit il segno, gli altri il modulo; da a , due zeri.
- Complemento a 2: da a , uno zero solo, e la somma serve anche per la sottrazione. Decodifica: l’MSB pesa (oppure: naturale meno se l’MSB è 1). Cambiare segno: inverti tutti i bit e aggiungi 1.
- Overflow in CA2 se e solo se i due addendi hanno lo stesso segno e il risultato il segno opposto. Il riporto in uscita da solo non dice niente.
- Virgola fissa: dopo la virgola pesi , , . Virgola mobile: , con mantissa ed esponente (nella versione del prof in CA2 su 8 bit, letta come ).
14.2Come si riconosce e come si fa
| Se vedi | Fai |
|---|---|
| addendi con pedici diversi | porta tutto in una base, poi somma; controlla con l’altra strada |
| da 16 o 8 a 2 | ogni cifra diventa 4 o 3 bit, tutti scritti |
| da 2 a 8 o 16 | gruppi da destra, padding di zeri a sinistra |
| ”rappresenta in CA2 su bit” | su bit, inverti, ; controlla che l’MSB sia 1 |
| “ in CA2” | , scarta il riporto oltre l’-esimo bit, controlla l’overflow con i segni |
| ”una sequenza di bit, tre letture” | naturale, modulo e segno, CA2 |
La somma fra basi, i due modi:
| passo | strada A, dal decimale | strada B, dal binario (solo basi 2, 8, 16) |
|---|---|---|
| 1 | ogni addendo in base 10 con i pesi | ogni addendo in binario: 3 bit per cifra ottale, 4 per cifra esadecimale |
| 2 | somma in base 10 | somma in colonna con la riga dei riporti |
| 3 | risultato nelle basi richieste con i resti | risultato in 8 e 16 con i gruppi, in 10 con i pesi |
Con risultati da marcare SI/NO, converti il tuo risultato in tutte le basi delle opzioni: quelle sbagliate sono di solito il risultato con un riporto dimenticato.
14.3Trappole
- Leggere i resti dal primo all’ultimo: il primo è la cifra meno significativa.
- Gruppi di bit da sinistra, o una cifra esadecimale scritta con meno di 4 bit.
- CA2: dimenticare il , o scrivere il positivo con meno di bit prima di invertire.
- Dire overflow perché c’è un riporto in uscita.
- Sommare cifra per cifra due numeri in basi diverse.
14.4Verifica
Domanda 48
Quanto vale in base 10?
Risposta e spiegazione
c)60
. Controllo con i bit: .
- a) legge C come 9 o somma : le lettere vanno convertite (C = 12).
- b) scrive 3 e 12 uno accanto all’altro invece di pesarli.
- d) è .
Domanda 49
Come si scrive in complemento a 2 su 8 bit?
Risposta e spiegazione
c)11010011
= 00101101. Inverto: 11010010. Aggiungo 1: 11010011. Controllo: .
- a) è modulo e segno.
- b) è l’inversione senza il (complemento a 1).
- d) è .
Domanda 50
La sequenza 10010110 letta in complemento a 2 su 8 bit vale:
Risposta e spiegazione
c)
L’MSB pesa : . Oppure naturale meno : .
- a) è la lettura come naturale.
- b) è la lettura in modulo e segno: segno meno, modulo
0010110= 22. - d) mette il segno davanti al naturale.
Domanda 51
Si calcola in complemento a 2 su 8 bit. Cosa succede?
Risposta e spiegazione
a)Il risultato è 10010110 e c’è overflow: due positivi danno un negativo
01011010 + 00111100 = 10010110, senza riporto in uscita. Il risultato ha MSB 1, cioè vale : due addendi positivi danno un risultato negativo, quindi overflow. Il motivo è che , il massimo su 8 bit in CA2.
- b) in CA2
10010110non vale 150. - c) qui non esce nessun riporto; e comunque il riporto non è il criterio.
- d) l’overflow è proprio un caso di addendi con lo stesso segno.
Domanda 52
Quanto vale ?
Risposta e spiegazione
a)
, , somma 44. In base 16: , cioè .
- b) : un’unità in più. Il risultato in ottale è .
- c) ; quello giusto è .
- d) scrive 44 con il pedice sbagliato: .
Esercizio breve (stile domanda 4). Calcola mostrando tutti i passaggi, e dai il risultato in base 2, 8, 10 e 16.
Soluzione
In binario. : , , quindi . : , , quindi .
Somma in colonna, da destra (bit 0 a destra):
| bit 6 | bit 5 | bit 4 | bit 3 | bit 2 | bit 1 | bit 0 | |
|---|---|---|---|---|---|---|---|
| riporti | 1 | 1 | |||||
| primo | 1 | 1 | 1 | 0 | 1 | 0 | |
| secondo | 1 | 1 | 0 | 1 | 0 | 1 | |
| somma | 1 | 1 | 0 | 1 | 1 | 1 | 1 |
Bit 0, 1, 2, 3: una sola cifra a 1, nessun riporto. Bit 4: con riporto 1. Bit 5: con riporto 1. Bit 6: il riporto.
Risultato: ; gruppi da 3 da destra ; gruppi da 4 ; pesi .
Controllo in base 10: , , . Verificato anche con Python.
15Tipi di dati e conversioni
Teoria: Tipi di dati e conversioni · Esercizi: Tipi di dati e conversioni (esercizi)
15.1Da sapere
- Un tipo è un insieme di valori più le operazioni su quei valori. Serve a interpretare i bit, a sapere quanta memoria riservare e a trovare gli errori di tipo in compilazione.
- Tipi predefiniti: integral (
char,short,int,long, consignedounsigned) e floating (float,double,long double). Le dimensioni dipendono dall’implementazione; su gccintefloat4 byte,double8. sizeofè un operatore unario che dà i byte di un tipo o di un’espressione; tiposize_t, si stampa con%zu. In Csizeof('a')vale 4, perché'a'è unint.- Conversioni implicite nelle espressioni: se un operando è floating, l’altro sale e la divisione è vera. Nell’assegnazione il valore va al tipo di sinistra: da floating a intero tronca.
- Cast
(tipo)espr: lega più di*e/, quindi(float)a / bconverteaprima della divisione,(float)(a / b)dopo. a / bfra interi tronca verso zero; il resto ha il segno del dividendo: , .- Gli
unsignedgirano modulo ; duefloatnon si confrontano con == ma con una soglia.
15.2Come si riconosce e come si fa
| Se vedi | Fai |
|---|---|
| una divisione | guarda i tipi dei due operandi, non della variabile a sinistra |
| un cast | dove sta? su un operando converte prima, sul risultato dopo |
int i = 3.99 o (int)x | tronca: 3 |
| arrotondare | (int)(x + 0.5) per |
unsigned char oltre 255 | sottrai 256 |
15.3Trappole
float f = 7 / 2;vale 3.0.(float)(a / b)tronca prima di convertire.- Costanti
100dove serve100.0. unsignedconi >= 0come condizione: sempre vera.
15.4Verifica
Domanda 53
Con int a = 7, b = 2;, cosa stampa il frammento?
float f = a / b;
float g = (float)(a / b);
float h = (float)a / b;
printf("%.1f %.1f %.1f", f, g, h);
Risposta e spiegazione
d)3.0 3.0 3.5
f: a / b è fra interi, vale 3, poi diventa 3.0. g: il cast arriva dopo la divisione intera, 3.0. h: il cast converte a prima, la divisione è fra float e int, quindi reale: 3.5.
- crede che la variabile a sinistra cambi la divisione.
- crede che il cast sul risultato recuperi la parte persa.
- ignora il cast su
a.
Domanda 54
Cosa stampa printf("%d %d %d %d", i, r, -17 / 5, -17 % 5); dopo int i = 3.99; int r = (int)(2.6 + 0.5);?
Risposta e spiegazione
b)3 3 -3 -2
3.99 in un int si tronca: 3. , troncato 3 (è l’arrotondamento di 2,6). tronca verso zero: . Il resto ha il segno del dividendo: .
- a) arrotonda 3.99 e usa la divisione “verso il basso” dei matematici.
- c) tronca bene ma divide verso .
- d) arrotonda dove si tronca.
Domanda 55
Cosa stampa unsigned char c = 250; c += 10; printf("%d", c);?
Risposta e spiegazione
b)4
Un unsigned char ha 8 bit, valori da 0 a 255: il conto si fa modulo 256, (verificato).
- a) ignora il limite del tipo.
- c) è 250 letto come
charcon segno, prima della somma. - d) crede che si fermi al massimo.
Domanda 56
Si vuole la media di int voti[4] = {28, 30, 25, 26}; con int somma già calcolata (109). Quale espressione dà 27.25?
Risposta e spiegazione
c)(float)somma / 4
Il cast converte somma prima della divisione, che diventa reale: (verificato con %.2f: 27.25).
- a) divisione intera, 27.
- b) tronca e poi converte: 27.00.
- d)
/e*vanno da sinistra: primasomma / 4intera (27), poi per 1.0.
Esercizio breve. Traccia il frammento e scrivi l’output.
int a = 9, b = 4, i;
float x, y;
x = a / b;
y = a / (float)b;
i = y * 2;
x = (int)y + x;
printf("%.2f %.2f %d\n", x, y, i);
Soluzione
| istruzione | regola | x | y | i |
|---|---|---|---|---|
x = a / b; | due int: divisione intera, 2, poi diventa 2.0 | 2.0 | ? | ? |
y = a / (float)b; | il cast su b rende reale la divisione | 2.0 | 2.25 | ? |
i = y * 2; | 4.5 in un int si tronca | 2.0 | 2.25 | 4 |
x = (int)y + x; | il cast lega più di +: | 4.0 | 2.25 | 4 |
Output: 4.00 2.25 4 (verificato). Controllo: ogni troncamento avviene solo dove un valore reale finisce in un int o passa per un cast a int, e sono due righe su quattro.
16Struct, typedef ed enum
Teoria: Struct, typedef ed enum · Esercizi: Struct, typedef ed enum (esercizi) · Prova 2024: domanda 6
16.1Da sapere
- Una
structaggrega campi di tipo diverso (l’array solo dello stesso tipo); ai campi si accede per nome con il punto:s.campo. Il punto ha la precedenza più alta. - La definizione del tipo non alloca memoria; la dichiarazione di una variabile sì. In C senza
typedefil tipo si chiamastruct Nome. typedefdà un nome nuovo a un tipo esistente:typedef struct { ... } Studente;permetteStudente s;.- Assegnazione fra struct:
b = a;copia tutti i campi, ed è una copia indipendente. Il confronto == fra struct non compila. - Memoria: almeno la somma dei campi (
char nome[20]sono 20 byte); il compilatore può aggiungere padding, ma negli esercizi basta la somma. enum: costanti intere con nome, da 0 crescenti di 1; se una costante ha un valore, le successive continuano da lì. Si stampa con%do si traduce con unoswitch.- Array di struct:
v[i].campo. L’indice va sull’array, il punto sull’elemento.
16.2Come si riconosce e come si fa
| Se vedi | Fai |
|---|---|
| ”quanti elementi hanno …“ | contatore a 0 prima del ciclo, if dentro |
| ”media di …“ | somma e contatore; dopo il ciclo, divisione solo se il contatore è positivo |
| ”il nome di chi ha il più alto” | indice del migliore, che parte da 0; alla fine stampa v[imax].nome |
| due richieste indipendenti | due if separati, mai if ... else if |
| ”fra e estremi inclusi” | x >= a && x <= b |
| ”quanta memoria” | somma dei campi per il numero di variabili; la definizione da sola vale zero |
Algoritmo su un array di struct (domanda 6):
- Accanto a ogni richiesta scrivi lo schema: contatore, somma, indice del migliore, ricerca.
- Inizializza tutto prima del ciclo.
- Un solo
for (i = 0; i < N; i++), unifseparato per richiesta, sul campo giusto. - Dopo il ciclo: divisioni (con il contatore diverso da 0) e stampe.
- Prova su un array di 3-5 elementi inventato, con un elemento sugli estremi.
16.3Trappole
classe.voto[i]al posto diclasse[i].voto.s.nome = "Anna": un campo array non si assegna.- Media fra interi, o dentro il ciclo, o divisa per zero.
- Massimo con il valore iniziale inventato (0) invece dell’indice 0.
;mancante dopo la graffa dellastruct.
16.4Verifica
Domanda 57
Quanta memoria occupa S v[10]; con typedef struct { char nome[15]; int eta; float media; } S;, contando la somma dei campi?
Risposta e spiegazione
d)230 byte
Un elemento: byte; dieci elementi: 230. Con gcc sizeof(S) vale 24 e sizeof(v) 240, perché dopo i 15 char il compilatore aggiunge un byte di padding per allineare l’int (verificato): all’esame la risposta attesa è la somma dei campi, e il padding va citato se si vuole la risposta esatta.
- è un solo elemento.
- conta
nomecome 1 byte. vè una dichiarazione: alloca.
Domanda 58
Con typedef enum { ORO = 1, ARGENTO, BRONZO, NESSUNA = 0 } medaglia;, quanto vale BRONZO?
Risposta e spiegazione
b)3
ORO vale 1, le successive continuano: ARGENTO 2, BRONZO 3. NESSUNA ha il suo valore esplicito (verificato: printf("%d", BRONZO) stampa 3).
- a) parte da 0 ignorando
ORO = 1. - c) confonde con
NESSUNA. - d) l’ordine delle costanti è libero.
Domanda 59
Cosa stampa il frammento?
punto a = {3, 4};
punto b;
b = a;
b.x = 10;
printf("%d %d", a.x, b.x);
(con typedef struct { int x; int y; } punto;)
Risposta e spiegazione
a)3 10
b = a copia tutti i campi in b, che è una variabile separata: cambiare b.x non tocca a.
- b) tratta l’assegnazione come un collegamento.
- c) ignora
b.x = 10. - d) fra struct l’assegnazione è permessa; è il confronto == che non compila.
Domanda 60
Con Studente classe[N]; e un campo float voto, quale riga somma correttamente i voti?
Risposta e spiegazione
d)somma += classe[i].voto;
classe[i] è l’elemento (una struct), .voto il suo campo.
- a) mette l’indice sul campo:
classeè un array e non ha campi. - c)
->vuole a sinistra un puntatore a struct,classe[i]è una struct. - b) rovescia i nomi.
Esercizio breve (stile domanda 6). Con
#define N 5
typedef struct {
char sigla[4];
int pezzi;
float peso;
} pacco;
pacco p[N];
già riempito, stampa quanti pacchi hanno 0 pezzi, il peso totale (pezzi per peso) e la sigla del pacco con il peso unitario più alto (il primo a parità).
Soluzione
#include <stdio.h>
#define N 5
typedef struct {
char sigla[4];
int pezzi;
float peso;
} pacco;
int main(void)
{
pacco p[N] = {{"A1", 3, 2.5f}, {"B2", 0, 1.0f}, {"C3", 5, 4.0f},
{"D4", 2, 4.0f}, {"E5", 0, 0.5f}};
int i;
int vuoti = 0;
float totale = 0;
int imax = 0;
for (i = 0; i < N; i++) {
if (p[i].pezzi == 0)
vuoti++;
totale += p[i].pezzi * p[i].peso;
if (p[i].peso > p[imax].peso)
imax = i;
}
printf("vuoti: %d\n", vuoti);
printf("peso totale: %.1f\n", totale);
printf("piu' pesante: %s\n", p[imax].sigla);
return 0;
}
All’esame basta il corpo di main dopo le dichiarazioni; l’array di prova serve a verificare.
vuoticonta B2 ed E5: 2.totaleè .- Il peso più alto è 4.0, di C3 e D4: con
>resta il primo, C3.
Output verificato: vuoti: 2, peso totale: 35.5, piu' pesante: C3. Controllo: i due pacchi vuoti non cambiano il totale, quindi basta sommare i tre pieni: .
17Puntatori
Teoria: Puntatori · Esercizi: Puntatori (esercizi) · Prova 2024: domanda 1
17.1Da sapere
- Un puntatore è una variabile che memorizza come right value un indirizzo di memoria, la locazione di un’altra variabile: la prima variabile punta alla seconda.
int *p;dichiara un puntatore aint, e alloca solo il puntatore. &xè l’indirizzo dix(il suo left value); si applica solo a oggetti in memoria, non a costanti o espressioni.*pè la variabile puntata dap, usabile a sinistra e a destra dell’=.- Un puntatore va inizializzato prima dell’uso;
NULLvuol dire “non punta a niente”, e*pconpuguale aNULLè indefinito. p = qcopia l’indirizzo: crea un alias.*p = *qcopia il valore.*p++è*(p++): incrementa il puntatore.(*p)++e++*pincrementano la variabile puntata.*++psposta e poi legge.- Il nome di un array è l’indirizzo del primo elemento, un puntatore costante:
a[i]è*(a + i), ea = poa++non compilano. p + iavanza di elementi;q - pè il numero di elementi fra i due.p->campoè(*p).campo: punto se a sinistra c’è una struct, freccia se c’è un puntatore a struct.const int *p: non si scrive*p, si spostap.int *const p: il contrario.- Un puntatore occupa sempre la stessa memoria (8 byte a 64 bit), qualunque sia il tipo puntato.
17.2Come si riconosce e come si fa
| Se vedi | Fai |
|---|---|
| ”è ammissibile?“ | tipi dei due lati: & aggiunge un livello, * lo toglie; devono coincidere, e a sinistra serve qualcosa di modificabile |
| una sequenza di assegnazioni | tabella con “p punta a” e una colonna per variabile; se a sinistra c’è p si sposta la freccia, se c’è *p si scrive in fondo alla freccia |
* e ++ insieme | il postfisso lega per primo; prefisso e * da destra |
| un puntatore che scorre un array | disegna la riga di celle e muovi la freccia; p - a è l’indice |
. o -> | struct a sinistra: punto; puntatore: freccia |
Batteria SI/NO della domanda 1: per “ammissibile” le note intendono che compila senza errori e senza warning. Le regole sui tipi, una riga per istruzione:
- Scrivi il tipo del lato sinistro e del lato destro.
- Intero a puntatore o puntatore a intero: NO.
- Puntatori a tipi diversi (
char *eint *,int **eint *): NO. - A sinistra un array, un
&x, o una cellaconst: NO. - Tutto il resto con tipi uguali: SI.
17.3Trappole
*p++per incrementare il valore: incrementa il puntatore.- Confondere
p = qcon*p = *q. char* a, b;: soloaè un puntatore.*p.campoinvece dip->campo: il punto lega più dell’asterisco.- Credere che
q - psia in byte, o chesizeofdi un puntatore dia la lunghezza della stringa. - Rispondere SI a “dichiarare un puntatore alloca la variabile puntata”.
17.4Verifica
Domanda 61
Con int a = 4; int *p = &a; char c = 'x'; char *pc;, quale istruzione è ammissibile?
Risposta e spiegazione
c)pc = &c;
pc è char *, &c è char *: tipi uguali.
- a)
char *controint *: gcc 16 dàerror: assignment to 'char *' from incompatible pointer type 'int *'. - b)
intcontroint *:error: ... makes integer from pointer without a cast. - d)
int *controint:error: ... makes pointer from integer without a cast.
Tutti e tre verificati con gcc -std=c11 -Wall -Wextra -Wpedantic.
Domanda 62
Cosa stampa il frammento?
int v[4] = {5, 8, 1, 6};
int *p = v + 1;
int x;
x = (*p)++ + *(p + 2);
printf("%d %d", x, v[1]);
Risposta e spiegazione
a)14 9
p punta a v[1], che vale 8. (*p)++ entra nel conto con 8 e poi porta v[1] a 9. *(p + 2) è v[3], 6. .
- b) usa il valore dopo l’incremento.
- c) dimentica che
(*p)++cambiav[1]. - d) conta
p + 2davinvece che dap(prendev[2], 1) e dimentica l’incremento div[1].
Domanda 63
Cosa stampa il frammento?
int x = 1, y = 2;
int *p = &x, *q = &y;
*p = *q;
q = p;
*q = 9;
printf("%d %d", x, y);
Risposta e spiegazione
b)9 2
| istruzione | p punta a | q punta a | x | y |
|---|---|---|---|---|
| dichiarazioni | x | y | 1 | 2 |
*p = *q; | x | y | 2 | 2 |
q = p; | x | x | 2 | 2 |
*q = 9; | x | x | 9 | 2 |
Dopo q = p i due puntatori sono alias di x, quindi *q = 9 scrive in x.
- a) lascia
qsuy. - c) crede che
*p = *qcolleghixey. - d) non vede la scrittura attraverso l’alias.
Domanda 64
Con int a[6] = {2, 4, 6, 8, 10, 12}; int *p = &a[1], *q = &a[5];, quale affermazione è vera?
Risposta e spiegazione
c)q - p vale 4 e *q - *p vale 8
Fra a[1] e a[5] ci sono 4 elementi; i valori puntati sono 12 e 4, differenza 8 (verificato: 4 8).
- a) la differenza fra puntatori conta elementi, non byte.
- b)
*a + 2è ,*(a + 2)èa[2], 6: diversi. - d) il nome di un array non si riassegna, non compila.
Domanda 65
Cosa stampa il frammento?
char s[] = "pointer";
char *p = s + 3;
printf("%s %c", p, *(p + 2));
Risposta e spiegazione
a)nter e
s + 3 punta alla n (indici: p 0, o 1, i 2, n 3). %s stampa da lì al terminatore: nter. *(p + 2) è s[5], e.
- b) parte da
s[2]. - c) sbaglia il secondo:
p + 2ès[5], nons[4]. - d) crede che
%ssi fermi ap.
Esercizio breve (stile domanda 1). Dato
int n = 6, *p = &n, **pp = &p;
int w[3] = {1, 5, 9};
dire se sono ammissibili: 1. p = w; 2. *pp = &n; 3. pp = &n; 4. w = p;. Dire se sono vere o false, a partire dal codice iniziale: 5. **pp vale 6; 6. dopo p = w;, *(p + 1) vale 5; 7. sizeof(pp) è maggiore di sizeof(p); 8. *w + 2 e *(w + 2) hanno lo stesso valore.
Soluzione
- Vero:
wvale&w[0], di tipoint *comep. - Vero:
*ppèp(int *),&nèint *. - Falso:
int **controint *,error: assignment to 'int **' from incompatible pointer type 'int *'. - Falso: un array non si riassegna,
error: assignment to expression with array type. - Vero:
*ppèp,**ppèn, 6. - Vero:
p + 1punta aw[1], 5. - Falso: tutti e due contengono un indirizzo, 8 byte ciascuno.
- Falso:
*w + 2è ,*(w + 2)èw[2], 9.
Le righe 1-4 compilate con gcc 16, le 5-8 eseguite (output 6 8 8 3 9 e 5).
Esercizio breve. Cosa stampa il frammento?
int v[6] = {3, 1, 4, 1, 5, 9};
int *p = v;
int s = 0;
while (p < v + 6) {
s += *p;
p += 2;
}
printf("%d %td\n", s, p - v);
Soluzione
| giro | p punta a | *p | s dopo |
|---|---|---|---|
| 1 | v[0] | 3 | 3 |
| 2 | v[2] | 4 | 7 |
| 3 | v[4] | 5 | 12 |
| fine | v + 6 | non si legge |
Output: 12 6 (verificato). v + 6 punta “una cella dopo l’ultima”: si può calcolare e confrontare, non dereferenziare. Controllo: le celle pari sono 3, 4, 5, somma 12.
18Ultimo giro
Il giorno prima, a occhi chiusi:
- Tracciare un
forconi++nelprintfe un aggiornamento strano (i += i,i /= 2), con la tabella a due colonne e il valore di uscita - Dire dove salta
continuenelfor(suespr3) e chebreaksaltaespr3 - Tracciare uno
switchsenzabreakcondefaultin mezzo - Riconoscere
x++contro++xe la lazy evaluation di&&e|| - Divisione intera,
%con i negativi, posizione del cast - Scrivere una figura con due cicli, condizione su , lato in una
#define - Convertire fra basi 2, 8, 10, 16 in tutte le direzioni, e la somma fra basi con le due strade
- CA2 su 8 bit: scrivere , leggere una sequenza nei tre modi, riconoscere l’overflow dai segni
- Completare una tavola di verità con NOT > AND > OR e negare una condizione con De Morgan
- Batteria SI/NO sui puntatori: tipi dei due lati, alias,
*p++,sizeofdi un puntatore, puntatore non inizializzato - Algoritmo su un array di struct: contatori e somme prima del ciclo,
ifseparati,v[i].campo, media con il caso zero - Stringhe: terminatore,
sizeofcontro lunghezza,%ssenza& - Matrice: , diagonali, trasposta solo per
- Rifare a tempo almeno una simulazione: Simulazione provetta 1, Simulazione provetta 2, Simulazione provetta 3, Simulazione provetta 4 (la più difficile)