Programmazione non strutturata e salti
Come un salto cambia il flusso di esecuzione
Ai primissimi albori dell’informatica (anni ‘50 e primi anni ‘60), i programmatori scrivevano il codice direttamente in linguaggio macchina o in Assembly, oppure nei primi linguaggi ad alto livello come le prime versioni di FORTRAN e BASIC. In quel mondo, il modo più naturale per prendere una decisione o ripetere un blocco di istruzioni era dire al processore: “Salta direttamente alla riga 140” (GOTO 140 o JMP indirizzo).
All’inizio questo approccio sembrava comodissimo e veloce. Ma non appena i programmi superarono qualche centinaio di righe, gli ingegneri si trovarono di fronte a un incubo: seguendo i salti in avanti e all’indietro che si incrociavano da ogni punto del programma, le frecce del diagramma di flusso assomigliavano a un piatto di spaghetti aggrovigliati (Spaghetti Code). Capire da dove fosse arrivato il programma in un certo punto, trovare un bug o modificare una funzionalità senza rompere tutto il resto diventò quasi impossibile.
In questa lezione analizziamo come funzionano i salti a basso livello, cos’è la programmazione non strutturata e perché la comprensione dei suoi difetti ha portato alla rivoluzione della programmazione strutturata.
Flusso di controllo sequenziale e istruzioni di salto
L’esecuzione sequenziale e il Program Counter (PC)
All’interno della CPU esiste un registro speciale chiamato Program Counter (PC, o Instruction Pointer, IP), che contiene l’indirizzo di memoria della prossima istruzione macchina da eseguire.
In assenza di istruzioni di controllo del flusso:
- La CPU preleva (fetch) l’istruzione puntata dal
PC. - Incrementa automaticamente il
PCper puntare all’istruzione immediatamente successiva in memoria. - Esegue (execute) l’istruzione corrente.
Questo comportamento predefinito si chiama flusso di controllo sequenziale: le istruzioni vengono eseguite una dopo l’altra, dall’alto verso il basso.
I salti a basso livello e l’istruzione goto in C
Per alterare il flusso sequenziale, i processori mettono a disposizione le istruzioni di salto (branch / jump), che sovrascrivono direttamente il valore del Program Counter con un nuovo indirizzo:
- Salto incondizionato (
JMP etichettain Assembly,goto etichetta;in C): trasferisce immediatamente l’esecuzione al punto contrassegnato dall’etichetta (etichetta:), qualunque sia lo stato del programma. - Salto condizionato (
JE,JNE,JL,JGin Assembly,if (cond) goto etichetta;in C): valuta una condizione logica; se è vera salta all’etichetta, altrimenti prosegue con l’istruzione successiva.
In linguaggio C la sintassi di goto utilizza un’etichetta (label) seguita dai due punti ::
int i = 0;
inizio_ciclo: /* Etichetta di destinazione del salto */
printf("%d\n", i);
i = i + 1;
if (i < 5) {
goto inizio_ciclo; /* Salto all'indietro (crea un ciclo manuale) */
}Il problema dello “Spaghetti Code” e i Grafi di Flusso (CFG)
Cos’è un Grafo di Controllo del Flusso (Control Flow Graph — CFG)
Un CFG è un grafo orientato in cui:
- I nodi rappresentano i blocchi base di istruzioni sequenziali e i predicati decisionali.
- Gli archi orientati rappresentano i possibili trasferimenti del controllo (salti).
Perché la programmazione non strutturata è dannosa?
Nel 1968 l’informatico olandese Edsger W. Dijkstra pubblicò una celebre lettera intitolata “Go To Statement Considered Harmful” (“L’istruzione goto considerata dannosa”), osservando che la qualità del codice dei programmatori era inversamente proporzionale al numero di goto contenuti nei loro programmi.
I motivi tecnici sono profondi:
- Grafo di flusso non riducibile (intreccio dei cicli): usando
gotoarbitrari è possibile saltare dall’esterno direttamente nel mezzo di un ciclo (saltando l’inizializzazione delle variabili!) oppure incrociare due cicli in modo che nessuno dei due sia contenuto nell’altro. - Perdita della località del ragionamento (Mancanza del principio Single-Entry Single-Exit): se in mezzo a una funzione troviamo un’etichetta
punto_x:, per sapere quanto valgono le variabili in quel punto non basta leggere le righe subito sopra: dobbiamo cercare in tutto il file tutti i possibiligoto punto_x;provenienti dall’alto o dal basso! - Impossibilità di verifica formale e scarsa manutenibilità: non è possibile scomporre un programma “a spaghetti” in sottoprogrammi indipendenti, perché i blocchi hanno molteplici punti di ingresso e molteplici punti di uscita intrecciati.
flowchart TD subgraph Spaghetti["CFG Non Strutturato ('Spaghetti Code': cicli incrociati)"] A["Inizio"] --> B{"Cond 1?"} B -->|"Sì"| C["Blocco C"] B -->|"No"| D["Blocco D\n(Salta dentro l'altro ramo!)"] C --> E{"Cond 2?"} E -->|"Sì"| D D --> F{"Cond 3?"} F -->|"Sì"| C E -->|"No"| G["Fine"] F -->|"No"| G end
Osserva nel diagramma qui sopra i nodi C e D: è possibile entrare nel ciclo sia passando da C sia entrando direttamente da D! Un grafo simile si dice irriducibile.
Dalle celle RAM alle variabili
Nel modello RAM possiamo tradurre una ripetizione in un test seguito da un salto all’indietro. Con una cella M[0] inizializzata a 2, il frammento L: se M[0] = 0 vai a F; M[0] ← M[0] - 1; vai a L; F: arresta raggiunge L con i valori 2, 1, 0. Il testo è fisso. L’esecuzione cambia dinamicamente la cella e il contatore delle istruzioni.
Un identificatore dà un nome all’oggetto cui ci riferiamo. Il tipo determina valori e operazioni ammessi. L’oggetto occupa memoria durante la propria esistenza e il valore può cambiare per assegnamento. Più invocazioni della stessa funzione possono avere oggetti distinti per lo stesso identificatore locale. Il legame fra nome e oggetto si comprende insieme ad ambito e durata, trattati in scope e tempo di vita.
Esempi guidati
Esempio 1: Calcolo del fattoriale in stile non strutturato
Vediamo come veniva scritto il calcolo del fattoriale usando etichette e goto invece di un ciclo strutturato, insieme al suo grafo di flusso.
#include <stdio.h>
int main(void) {
int n = 5;
int fatt = 1;
if (n <= 1) goto fine;
ciclo:
fatt = fatt * n;
n = n - 1;
if (n > 1) goto ciclo;
fine:
printf("Fattoriale: %d\n", fatt);
return 0;
}Anche in un esempio così piccolo, l’uso combinato di un salto in avanti (goto fine;) e di un salto all’indietro (goto ciclo;) costringe il lettore a simulare mentalmente i salti come farebbe una CPU.
Esempio 2: “Spaghetti Code” con salti incrociati e traccia di esecuzione
Analizziamo un frammento classico di codice non strutturato (spesso proposto negli esercizi d’esame per testare la comprensione del flusso e poi chiederne la ristrutturazione):
#include <stdio.h>
int main(void) {
int x = 1, y = 10;
L1:
if (x >= y) goto L3;
x = x + 3;
if (x < 5) goto L2;
y = y - 2;
goto L1;
L2:
y = y - 1;
goto L1;
L3:
printf("Fine: x = %d, y = %d\n", x, y);
return 0;
}Grafo di Controllo del Flusso (CFG) in Mermaid:
flowchart TD START(["x = 1, y = 10"]) --> L1{"L1: x >= y ?"} L1 -->|"Vero"| L3["L3: Stampa x, y e termina"] L1 -->|"Falso"| INC["x = x + 3"] INC --> C2{"x < 5 ?"} C2 -->|"Vero"| L2["L2: y = y - 1"] C2 -->|"Falso"| DEC2["y = y - 2"] L2 --> L1 DEC2 --> L1
Traccia di esecuzione passo-passo:
- Inizio:
x = 1,y = 10. - Passaggio 1 in
L1:1 >= 10è Falsox = 1 + 3 = 4. Testx < 5(4 < 5) è Vero salta aL2y = 10 - 1 = 9salta aL1. - Passaggio 2 in
L1:4 >= 9è Falsox = 4 + 3 = 7. Testx < 5(7 < 5) è Falso eseguey = 9 - 2 = 7salta aL1. - Passaggio 3 in
L1:7 >= 7è Vero salta aL3! - Output:
Fine: x = 7, y = 7.
Errori frequenti
Errori da evitare
- Saltare con
gotooltre l’inizializzazione di una variabile
Se ungoto avanti;salta sopra una rigaint k = 10;ed entra in un punto del blocco in cuikviene poi letta (printf("%d", k);), la variabilekesiste in memoria ma non è stata inizializzata!- Scambiare un salto all’indietro per una semplice selezione
if
Unif (...) goto L;in cui l’etichettaL:si trova sopra l’istruzioneifnon è una selezione condizionale, ma un ciclo (iterazione)! Al contrario, seL:si trova sotto l’istruzioneif, si tratta di una selezione (salto di un blocco di codice).- Dimenticare che il codice cade nell’etichetta successiva (fall-through)
Un’etichettaL2:non blocca il flusso sequenziale! Se il codice sopraL2:non termina con ungotoo unreturn, l’esecuzione prosegue dritta entrando dentroL2:.
Esercizi di prova
Esercizio 1. Traccia di codice con goto (Base)
Determina l’output esatto del seguente programma C costruendo la traccia dei valori di a e b:
#include <stdio.h>
int main(void) {
int a = 2, b = 12;
inizio:
if (a >= b) goto fine;
a = a * 2;
b = b - 2;
goto inizio;
fine:
printf("a = %d, b = %d\n", a, b);
return 0;
}Soluzione
- Stato iniziale:
a = 2, b = 12.- Giro 1 (
inizio):2 >= 12Falsoa = 4,b = 10torna ainizio.- Giro 2 (
inizio):4 >= 10Falsoa = 8,b = 8torna ainizio.- Giro 3 (
inizio):8 >= 8Vero salta afine.Output:
a = 8, b = 8.
Esercizio 2. Riconoscere cicli vs selezioni nei salti (Base)
Nel seguente schema di codice astratto:
A: x = x + 1;
if (x < 10) goto B;
y = 0;
B: if (x < 5) goto A;Indica quale dei due goto realizza un’istruzione condizionale in avanti (selezione) e quale realizza un ciclo (iterazione), e determina i valori finali di x e y se inizialmente x = 3, y = 99.
Soluzione
if (x < 10) goto B;salta in avanti (salta la rigay = 0;), quindi realizza una selezione.if (x < 5) goto A;salta all’indietro versoA:, quindi realizza un ciclo (iterazione).- Traccia da
x = 3, y = 99:
- In
A:xdiventa4. Poiché4 < 10, salta aB(non eseguey = 0). InB:4 < 5è Vero, quindi torna adA.- In
A:xdiventa5. Poiché5 < 10, salta aB. InB:5 < 5è Falso, quindi il programma termina.- Valori finali:
x = 5,y = 99.
Esercizio 3. Disegno del CFG e individuazione di ciclo infinito (Intermedio)
Disegna in Mermaid il Control Flow Graph (CFG) del seguente codice e spiega per quali valori iniziali interi di n il programma termina e per quali entra in un ciclo infinito:
ciclo:
if (n == 0) goto fine;
n = n - 2;
goto ciclo;
fine:
printf("Terminato!\n");Soluzione
flowchart TD C{"ciclo: n == 0 ?"} -->|"Vero"| F["fine: Stampa 'Terminato!'"] C -->|"Falso"| SUB["n = n - 2"] SUB --> C
- Il programma termina solo se ed è pari (), perché sottraendo a ogni passo raggiungerà esattamente .
- Entra in un ciclo infinito se è dispari positivo (passa da a saltando lo ) oppure se (si allontana sempre più da verso ).
Esercizio 4. Fall-through tra etichette (Intermedio)
Qual è il valore finale di ris nel seguente frammento se codice = 1? E perché è un tipico errore di programmazione con goto?
int codice = 1, ris = 0;
if (codice == 1) goto caso1;
if (codice == 2) goto caso2;
caso1:
ris = ris + 10;
caso2:
ris = ris + 20;Soluzione
Il valore finale di
risè30(e non10!).
Spiegazione: Quandocodice == 1, il programma salta all’etichettacaso1:ed esegueris = 0 + 10 = 10. Poiché subito dopo non c’è un salto verso la fine, l’esecuzione “cade” (fall-through) direttamente nelle istruzioni dicaso2:, eseguendo ancheris = 10 + 20 = 30!
Esercizio 5. Analisi di un grafo “Spaghetti” con ingresso multiplo nel ciclo (Avanzato)
Traccia l’esecuzione del seguente programma (in cui il primo goto salta direttamente nel mezzo del ciclo L1–L2) e determina cosa stampa a video:
#include <stdio.h>
int main(void) {
int k = 1, s = 0;
goto L2;
L1:
k = k * 2;
L2:
s = s + k;
if (k < 4) goto L1;
printf("k = %d, s = %d\n", k, s);
return 0;
}Soluzione
- Inizio:
k = 1, s = 0.goto L2;salta sopraL1ed entra direttamente inL2:
s = 0 + 1 = 1.- Test
k < 4(1 < 4Vero) salta aL1.- In
L1:k = 1 * 2 = 2. Cade inL2:
s = 1 + 2 = 3.- Test
k < 4(2 < 4Vero) salta aL1.- In
L1:k = 2 * 2 = 4. Cade inL2:
s = 3 + 4 = 7.- Test
k < 4(4 < 4Falso) esce e stampa.Output:
k = 4, s = 7.
Provenienza del materiale
- Slide e dispensa ufficiale del corso:
C1PROG1U1L4_Programmazione_Non_Strutturata.pdf(Unità 1, Lezione 4 — Programmazione non strutturata, istruzioni di saltogotoe problema dello spaghetti code). - Marco Anisetti, Fondamenti,
Appunti_di_fine_Unita_1.pdf, cap. 3. - Guida unica di studio – Fondamenti,
Guida_Unita_1_teoria_approfondimenti_per_argomento.pdf, §§ 7–8. - Appunti Avanzati di Programmazione e Algoritmi I,
AppuntiInformatica-v3.pdf, § 5.