Appendice F
Utilizzare il debugger di Visual Studio
Obiettivi
Essere in grado di impostare i breakpoint e di eseguire un programma nel debugger.
Essere in grado di utilizzare il comando Continue per continuare l'esecuzione.
■
Essere in grado di utilizzare la finestra Locals per visualizzare e modificare i valori delle variabili.
■
Essere in grado di utilizzare la finestra Watch per valutare le espressioni.
■
Essere in grado di utilizzare i comandi Step Into, Step Out e Step Over per controllare l'esecuzione.
■
Essere in grado di utilizzare la finestra Autos per visualizzare le variabili che vengono utilizzate nei
comandi prossimi a quello corrente.
■
■
F.1 Introduzione
Nel Capitolo 2 avete imparato che esistono due tipi di errori, ovvero, errori di compilazione ed errori logici ed
avete imparato come eliminare i primi dal vostro codice. Gli errori logici (denominati anche bug) non
impediscono che un programma venga compilato con successo, ma possono far sì che il programma stesso
produca dei risultati erronei al momento dell'esecuzione. Molti produttori di compilatori C forniscono anche un
software noto come debugger, che vi permette di controllare l'esecuzione dei vostri programmi per individuare ed
eliminare gli errori logici. Il debugger si rivelerà come uno dei più importanti strumenti per lo sviluppo di
programmi. Questa appendice illustra le caratteristiche chiave del debugger del Visual Studio. L'Appendice H
illustra le caratteristiche e le possibilità offerte dal debugger GNU.
F.2 I breakpoint ed il comando Continue
Iniziamo il nostro studio del debugger investigando i breakpoint, che sono dei marcatori che possono essere
impostati in corrispondenza di ogni riga eseguibile del codice. Quando l'esecuzione del programma raggiunge un
breakpoint, viene effettuata una pausa, consentendovi di esaminare i valori delle variabili per aiutarvi a
determinare se ci sia un errore logico. Per esempio, potete esaminare il valore di una variabile che memorizza il
risultato di un calcolo per determinare se quest'ultimo sia stato eseguito correttamente. Si noti che tentare di
inserire un breakpoint in corrispondenza di una linea di codice che non sia eseguibile (come un commento)
imposterà il breakpoint alla prossima linea eseguibile di codice nella relativa funzione.
Per illustrare le caratteristiche del debugger, utilizziamo il programma in Figura F.1, che trova il massimo di tre
interi. L'esecuzione inizia in corrispondenza del main (righe 8–22). I tre interi vengono inseriti con la scanf (riga 15).
In seguito, gli interi sono passati a maximum (riga 19), che ne determina il massimo. Quest'ultimo è il valore
restituito al main dal comando return in maximum (riga 38). Il valore restituito viene poi visualizzato per mezzo del
comando printf (riga 19).
1 /* Fig. F.1: figG_01.c
2
Trovare il massimo di tre interi */
3 #include <stdio.h>
4
5 int maximum( int x, int y, int z ); /* prototipo di funzione */
6
7 /* l’esecuzione del programma inizia dalla funzione main */
8 int main( void )
9{
10
int number1; /* primo intero */
11
int number2; /* secondo intero */
12
int number3; /* terzo intero */
13
printf( "Enter three integers: " );
14
Copyright (C) 2010 Apogeo
15
scanf( "%d%d%d", &number1, &number2, &number3 );
16
17
/* number1, number2 e number3 sono gli argomenti
18
della chiamata di funzione a maximum */
19
printf( "Maximum is: %d\n", maximum( number1, number2, number3 ) );
20
21
return 0; /* indica che il programma è terminato con successo */
22 } /* fine della funzione main */
23
24 /* Definizione della funzione maximum */
25 /* x, y e z sono i parametri */
26 int maximum( int x, int y, int z )
27 {
28
int max = x; /* si assuma che x sia il massimo */
29
if ( y > max ) { /* se y è maggiore di max, assegna y a max */
30
31
max = y;
32
} /* end if */
33
if ( z > max ) { /* se z è maggiore di max, assegna z a max */
34
35
max = z;
36
} /* end if */
37
return max; /* max è il valore massimo */
38
39 } /* fine della funzione maximum */
Fig. F.1 | Determinare il massimo di tre interi.
Creare un progetto in Visual C++ 2008 Express
Nei passi seguenti creerete un progetto che includa il codice della Figura F.1.
1. Selezionate File > New > Project... in Visual C++ 2008 Express per visualizzare la finestra di dialogo New Project.
2. Nell'elenco Project types:, selezionate Win32 e nell'elenco Templates, selezionate Win32Console Application.
3. Inserite un nome per il vostro progetto nel campo Name: e specificate dove volete salvarlo nel vostro computer
nel campo Location:, poi fate clic su OK.
4. Nella finestra di dialogo Win32 Application Wizard fate clic su Next >.
5. In Applicationtype: selezionate Console application e in Additional options: selezionate Empty project, poi fate clic su Finish.
6. Nella finestra Solution Explorer fate clic con il tasto destro sulla cartella Source Files del vostro progetto e
selezionate Add > Existing Item... per visualizzare la finestra di dialogo Add Existing Item.
7. Individuate la cartella contenente il codice degli esempi dell'Appendice H, selezionate il file con il codice e fate
clic su Add.
Abilitare la modalità di debug (Debug Mode) e inserire i breakpoint
Nei passi seguenti utilizzerete i breakpoint e diversi comandi del debugger per esaminare il valore della variabile
number1 dichiarata in Figura F.1.
1. Abilitare il debugger. Il debugger normalmente è abilitato per default. Nel caso in cui non lo sia, dovrete
cambiare le impostazioni del menu a tendina Solution Configurations (Figura F.2) situato nella barra degli
strumenti. Per far ciò, fate clic sulla freccia verso il basso del menu a tendina e poi selezionate Debug.
Fig. F.2 | Abilitare il debugger.
Copyright (C) 2010 Apogeo
2. Inserire i breakpoint. Aprite il file figG_01.c facendo doppio clic su di esso nel Solution Explorer. Per inserire un
breakpoint, fate clic dentro la barra grigia alla sinistra della finestra del codice (margin indicator bar in Figura F.3)
in prossimità della riga in cui volete effettuare l'interruzione oppure fate clic con il tasto destro su quella linea di
codice e selezionate Break- point > Insert Breakpoint. Potete impostare tanti breakpoint quanti ne saranno necessari.
Impostate i breakpoint in corrispondenza delle righe 14 e 19 del vostro codice. Un circoletto rosso apparirà sul
barra che indica il margine nel punto in cui avete fatto clic, in modo da indicare che un breakpoint è stato
impostato (Figura F.3). Quando il programma viene eseguito, il debugger effettua una pausa nell'esecuzione in
corrispondenza di ogni linea che contiene un breakpoint. Si dice che il programma si trova in break mode quando
il debugger lo mette in pausa. I breakpoint possono essere impostati prima di far girare un programma, mentre si
trova in break mode e mentre è in corso di esecuzione.
Fig. F.3 | Impostare due breakpoint.
3. Iniziare il debug. Dopo aver impostato i breakpoint nell'editor del codice, selezionate Build>Build Solution per
compilare il programma, poi selezionate Debug > Start Debugging per iniziare il processo di debugging. [Nota: Se non
compilate prima il programma, esso sarà comunque compilato nel momento in cui selezionerete Debug > Start
Debugging.] Quando eseguite il debug di un'applicazione console, appare una finestra Command Prompt (Figura F.4)
in cui potete specificare gli input del programma e vederne l'output. Il debugger entra in break mode nel momento
in cui l'esecuzione raggiunge il breakpoint in riga 14.
Fig. F.4 | Il programma Maximum Numbers in esecuzione.
4. Esaminare l'esecuzione del programma. In seguito all'ingresso in break mode in corrispondenza del primo
breakpoint (riga 14), l'IDE diventa la finestra attiva (Figura F.5). La freccia gialla alla sinistra della riga 14 indica
che tale linea contiene il prossimo comando da eseguire.
Fig. F.5 | Esecuzione del programma sospesa in corrispondenza del primo breakpoint.
Copyright (C) 2010 Apogeo
5. Utilizzare il comando Continue per riprendere l'esecuzione. Per riprendere l'esecuzione, selezionate Debug >
Il comando Continue riprende l'esecuzione del programma fino al prossimo breakpoint o fino al
raggiungimento della fine del main, a seconda di quale evento si verifichi per primo. Il programma continua ad
eseguire ed effettua una pausa in corrispondenza della riga 15. Inserite i valori 22, 85, e 17 per i tre interi. Il
programma esegue finché non si ferma al prossimo breakpoint (riga 19). Notate che, quando posizionate il vostro
puntatore del mouse sul nome della variabile number1, il valore in essa contenuto viene visualizzato in un Quick
Info box (Figura F.6). Come potete constatare, ciò può aiutarvi ad individuare degli errori logici nei vostri
programmi.
Continue.
Fig. F.6 | Quick Info box che visualizza il valore di una variabile.
6. Impostare un breakpoint in corrispondenza della parentesi di chiusura del main. Impostate un breakpoint in riga
22 del codice sorgente facendo clic sulla barra indicante il margine alla sinistra della riga 22. Questo fatto
impedirà al programma di chiudersi immediatamente dopo aver visualizzato il suo risultato. Quando
non ci sono più breakpoint in corrispondenza dei quali sospendere l'esecuzione, il programma eseguirà fino al
completamento e la finestra del Command Prompt verrà chiusa. Se non impostate questo breakpoint, non sarete in
grado di vedere l'output del programma prima che la finestra della console venga chiusa.
7. Continuare l'esecuzione del programma. Utilizzate il comando Debug > Continue per eseguire il codice fino al
prossimo breakpoint. Il programma visualizza il risultato del suo calcolo (Figura F.7).
Fig. F.7 | Output del programma.
8. Eliminare un breakpoint. Fate clic sul breakpoint nella barra indicante il margine.
9. Completare l'esecuzione del programma. Selezionate Debug > Continue per eseguire il programma fino al suo
completamento.
In questa sezione, avete imparato ad attivare il debugger e ad impostare i breakpoint in modo da esaminare i
risultati del codice mentre il programma è in esecuzione. Avete anche imparato come continuare l'esecuzione in
seguito alla sospensione di quest'ultima in corrispondenza di un breakpoint e come rimuovere i breakpoint.
F.3 Le finestre Locals e Watch
Nella sezione precedente avete imparato che la caratteristica Quick Info vi permette di esaminare il valore di una
variabile. In questa sezione imparerete ad usare la finestra Locals per assegnare nuovi valori alle variabili mentre il
vostro programma è in esecuzione. Userete la finestra Watch anche per esaminare il valore di espressioni più
complesse.
Copyright (C) 2010 Apogeo
1. Inserire i breakpoint. Cancellate i breakpoint esistenti selezionando Debug > Delete All Breakpoints. Poi impostate
un breakpoint in corrispondenza della riga 19 del codice sorgente facendo clic nella barra che indica il margine
alla sinistra della riga 19 (Figura F.8).
Fig. F.8 | Impostare i breakpoint in corrispondenza delle righe 25 e 28.
2. Iniziare il debugging. Selezionate Debug > Start. Inserite i valori 22, 85, e 17 in corrispondenza del prompt Enter
three integers: e premete Enter in modo che il vostro programma legga i valori che avete appena inserito.
3. Sospendere l'esecuzione del programma. Il debugger entra in break mode in corrispondenza della riga 19
(Figura F.9). A questo punto la riga 15 ha letto i valori che avete inserito per number1 (22), number2 (85) e number3
(17). La riga 19 rappresenta il prossimo comando da eseguire.
Fig. F.9 | L'esecuzione del programma è sospesa quando il debugger raggiunge il breakpoint della riga 19.
4. Esaminare i dati. In break mode potete esaminare il valore delle vostre variabili locali utilizzando la finestra
Locals del debugger, normalmente visibile nella parte inferiore sinistra dell'IDE quando siete in modalità di
debugging. Se non è visibile al momento, potete esaminare la finestra Locals, selezionando Debug > Windows > Locals.
La Figura F.10 mostra i valori delle variabili locali del main, ovvero, number1 (22), number2 (85) e number3 (17).
Fig. F.10 | Esaminare le variabili number1, number2 e number3.
5. Valutare le espressioni aritmetiche e booleane. Potete valutare le espressioni aritmetiche e booleane utilizzando
la finestra Watch. Potete tenere visibili fino a quattro finestre Watch. Selezionate Debug > Windows > Watch > Watch 1.
Nella prima riga della colonna Name digitate (number1 + 3) * 5, poi premete Enter. Il valore di questa espressione (125
Copyright (C) 2010 Apogeo
in questo caso) viene mostrato nella colonna Value (Figura F.11). Nella riga successiva della colonna Name digitate
number== 3, poi premete Enter. Questa espressione determina se il valore di number1 sia 3. Le espressioni contenenti
l'operatore == (o ogni altro operatore relazionale o di uguaglianza) vengono considerate delle espressioni di tipo
bool. Il valore dell'espressione in questo caso è false (Figura F.11), in quanto number1 al momento contiene 22, non 3.
Fig. F.11 | Esaminare i valori delle espressioni.
6. Modificare i valori. In base ai valori inseriti dall'utente (22, 85 e 17), il numero massimo mandato in output dal
programma dovrebbe essere 85. Tuttavia, potete utilizzare la finestra Locals per cambiare i valori delle variabili
durante l'esecuzione del programma. Ciò può rivelarsi utile per sperimentare diversi valori e per individuare gli
errori logici. Nella finestra Locals, fate clic sul campo Value nella riga corrispondente a number1 per selezionare il
valore 22. Digitate 90, poi premete Enter. Il debugger cambierà il valore di number1 e visualizzerà il suo nuovo
valore in rosso (Figura F.12).
Fig. F.12 | Modificare il valore di una variabile.
7. Impostare un breakpoint in corrispondenza della parentesi di chiusura del main. Impostate un breakpoint in riga
22 del codice sorgente per impedire al programma di chiudersi immediatamente dopo aver visualizzato il suo
risultato. Se non impostate questo breakpoint, non sarete in grado di vedere l'output del programma prima che la
finestra della console si chiuda.
8. Riprendere l'esecuzione e vedere il risultato del programma. Selezionate Debug > Continue per continuare
l'esecuzione del programma. La funzione main eseguirà fino al comando return statement in riga 21 e visualizzerà il
risultato. Notate che il risultato sarà 90 (Figura F.13). Questo dimostra che il Passo 7 ha modificato il valore di
number1 a 90 dal valore originale (85).
Fig. F.13 | L'output visualizzato dopo la modifica del valore della variabile number1.
9. Interrompere la sessione di debugging. Selezionate
Prompt. Rimuovete tutti i breakpoint rimanenti.
Debug > Stop Debugging.
Ciò chiuderà la finestra
Command
In questa sezione avete imparato ad utilizzare le finestre Watch e Locals per valutare le espressioni aritmetiche e
booleane. Avete anche imparato come modificare il valore di una variabile durante l'esecuzione del programma.
F.4 Controllare l'esecuzione utilizzando i comandi Step Into, Step
Over, Step Out e Continue
A volte eseguire un programma riga per riga vi può aiutare a verificare che il codice di una funzione venga
eseguito correttamente ed a individuare e correggere gli errori logici. I comandi che imparerete in questa sezione
vi permetteranno di eseguire una funzione riga per riga, di eseguire tutte le istruzioni di una funzione in un colpo
solo o di eseguire solamente le istruzioni rimanenti di una funzione (nel caso in cui abbiate già eseguito alcune
istruzioni dentro la funzione).
Copyright (C) 2010 Apogeo
1. Impostare un breakpoint. Impostate un breakpoint in corrispondenza della riga 19 facendo clic sulla barra che
indica il margine alla sinistra della riga.
2. Far partire il debugger. Selezionate Debug > Start. Inserite i valori 22, 85 e 17 al prompt Enter three integers:.
L'esecuzione si fermerà quando il programma raggiungerà il breakpoint in corrispondenza della riga 19.
3. Utilizzare il comando Step Into. Il comando Step Into esegue la prossima istruzione nel programma (riga 19), poi
si arresta immediatamente. Se quell'istruzione contiene una chiamata di funzione (come avviene in questo caso), il
controllo viene trasferito all'interno della funzione chiamata. Ciò vi permette di eseguire singolarmente ogni
comando all'interno della funzione per confermare l'esecuzione della funzione. Selezionate Debug > Step Into per
entrare nella funzione maximum. In seguito selezionate nuovamente Debug > Step Into in modo che la freccia gialla si
posizioni in corrispondenza della riga 28 come mostrato in Figura F.14.
4. Utilizzare il comando Step Over. Selezionate Debug > Step Over per eseguire il comando corrente (riga 28 in Figura
F.14) e trasferire il controllo alla riga 30 (Figura F.15). Il comando Step Over si comporta come il comando Step Into
quando la prossima istruzione da eseguire non contiene una chiamata di funzione. Vedrete come il comando Step
Over differisca dal comando Step Into nel Passo 10.
Fig. F.14 | Eseguire passo per passo la funzione maximum.
Fig. F.15 | Eseguire il comando corrente nella funzione maximum.
5. Utilizzare il comando Step Out. Selezionate Debug > Step Out per eseguire le istruzioni rimanenti nella funzione e
restituire il controllo alla prossima istruzione eseguibile (riga 21 in Figura F.1). Spesso, nelle funzioni più lunghe,
vorrete controllare alcune linee chiave di codice per poi continuare nel debugging del codice del chiamante. Il
comando Step Out vi permette di continuare l'esecuzione del programma nel chiamante senza dover eseguire riga
per riga l'intera funzione chiamata.
6. Impostare un breakpoint. Impostate un breakpoint alla fine del main in corrispondenza della riga 22 della Figura
F.1. Farete uso di questo breakpoint nel passo successivo.
7. Utilizzare il comando Continue. Selezionate Debug > Continue per continuare l'esecuzione fino al raggiungimento
del prossimo breakpoint in corrispondenza della riga 22. Usare il comando Continue si rivela utile quando volete
eseguire tutto il codice fino al prossimo breakpoint.
Copyright (C) 2010 Apogeo
8. Arrestare il debugger. Selezionate Debug > Stop Debugging per terminare la sessione di debugging. Ciò provocherà
la chiusura della finestra del Command Prompt.
9. Far partire il debugger. Prima di poter illustrare la prossima caratteristica del debugger, fate partire nuovamente
il debugger. Avviatelo, come avete fatto nel Passo 2, ed inserite 22, 85 e 17 in risposta al prompt. Il debugger entrerà
in break mode in corrispondenza della riga 19.
10. Utilizzare il comando Step Over. Selezionate Debug > Step Over (Figura F.16). Ricordatevi che questo comando si
comporta come il comando Step Into quando la prossima istruzione da eseguire non contiene una chiamata di
funzione. Nel caso in cui la prossima istruzione da eseguire contenga una chiamata di funzione, la funzione
chiamata verrà eseguita nella sua interezza (senza effettuare pause nell'esecuzione di nessuna istruzione all'interno
della funzione) e la freccia gialla avanzerà alla prossima linea eseguibile (dopo la chiamata di funzione) nella
funzione corrente. In questo caso il debugger eseguirà la riga 19, situata nel main (Figura F.1). La riga 19
richiamerà la funzione maximum. In seguito il debugger effettuerà una pausa in corrispondenza della riga 21,
ovvero, la prossima linea eseguibile nella funzione corrente, main.
Fig. F.16 | Utilizzare il comando Step Over.
11. Arrestare il debugger. Selezionate
tutti i breakpoint rimanenti.
Debug > Stop Debugging.
Ciò chiuderà la finestra
Command Prompt.
Rimuovete
In questa sezione avete imparato come usare il comando Step Into del debugger per correggere le funzioni
richiamate durante l'esecuzione del vostro programma. Avete visto come il comando Step Over possa essere
utilizzato per oltrepassare una chiamata di funzione. Avete utilizzato il comando Step Out per continuare
l'esecuzione fino alla fine della funzione corrente. Avete imparato anche che il comando Continue continua
l'esecuzione fino al raggiungimento di un altro breakpoint o all'uscita dal programma.
F.5 La finestra Autos
La finestra Autos visualizza le variabili utilizzate nell'istruzione precedentemente eseguita (includendo il valore di
ritorno di una funzione, se è il caso) e le variabili nella prossima istruzione da eseguire.
1. Impostare i breakpoint. Impostate i breakpoint in corrispondenza delle righe 14 e 19 nel main facendo clic sulla
barra che indica il margine.
2. Utilizzare la finestra Autos. Avviate il debugger selezionando Debug>Start. Quando il debugger entra in break
mode in corrispondenza della riga 14, aprite la finestra Autos (Figura F.17) selezionando Debug > Windows > Autos.
Dato che abbiamo appena iniziato l'esecuzione del programma, la finestra Autos elencherà soltanto le variabili
coinvolte nel prossimo comando da eseguire, ovvero in questo caso, number1, number2 e number3. Visualizzare il
valore memorizzato in una variabile vi permette di verificare che il vostro programma stia manipolando le
variabili correttamente. Notate che number1, number2 e number3 contengono valori negativi molto grandi. Tali valori,
che possono differire ogni volta che il programma viene eseguito, sono i valori non inizializzati delle variabili.
Questi valori imprevedibili (e spesso indesiderabili) sono la dimostrazione dell'importanza di inizializzare tutte le
variabili in C prima del loro utilizzo.
Copyright (C) 2010 Apogeo
Fig. F.17 | La finestra Autos mentre visualizza i valori di number1, number2 e number3.
3. Continuare l'esecuzione. Selezionate Debug > Continue per eseguire il programma fino al raggiungimento del
secondo breakpoint in corrispondenza della riga 19. Al prompt di input del programma, inserite i valori dei tre
interi. La finestra Autos aggiornerà i valori di number1, number2 e number3 dopo la loro inizializzazione. I loro valori
appariranno in rosso per indicare che sono stati appena modificati. (Figura F.18)
Fig. F.18 | La finestra Autos mentre visualizza le variabili locali number1, number2 e number3.
4. Inserire dei dati. Selezionate Debug > Step
ritorno della funzione maximum (Figura F.19).
Over
per eseguire la riga 19. La finestra
Autos
visualizza il valore di
Fig. F.19 | La finestra Autos mentre visualizza il valore di ritorno della funzione maximum.
5. Arrestare il debugger. Selezionate Debug > Stop Debugging per terminare la sessione di debugging. Rimuovete tutti
i breakpoint rimanenti.
F.6 Conclusione
In questa appendice avete imparato come inserire, disabilitare ed eliminare i breakpoint nel debugger di Visual
Studio. I breakpoint vi permettono di effettuare delle pause nell'esecuzione del programma in modo da esaminare i
valori delle variabili. Questa caratteristica vi aiuterà ad individuare e correggere gli errori logici nei vostri
programmi. Avete visto come utilizzare le finestre Locals e Watch per esaminare il valore di un'espressione e per
cambiare il valore di una variabile. Avete anche imparato i comandi Step Into, Step Over, Step Out e Continue che
possono essere utilizzati per determinare se una funzione venga eseguita correttamente. Infine avete imparato
come usare la finestra Autos per esaminare le variabili usate in particolare nel comando precedente ed in quello
successivo.
Esercizi di autovalutazione
F.1
Completate gli spazi in ognuna delle seguenti frasi:
a) Quando il debugger sospende l'esecuzione del programma in corrispondenza di un breakpoint, si dice che il programma
sia in __________.
b) La caratteristica __________ di Visual Studio 2008 vi permette di esaminare il valore di una variabile posizionando il
mouse sul nome della variabile nel codice.
c) Potete esaminare il valore di un'espressione usando la finestra __________ del debugger.
Copyright (C) 2010 Apogeo
d) Il comando __________ si comporta come il comando Step Into quando la prossima istruzione da eseguire non contiene
una chiamata di funzione.
F.2
Stabilite quali delle seguenti affermazioni sono vere e quali false. Nel caso siano false, spiegatene il motivo.
a) Quando l'esecuzione del programma viene sospesa in corrispondenza di un breakpoint, la prossima istruzione da eseguire
è quella dopo il breakpoint.
b) Quando il valore di una variabile viene modificato, diventa giallo nelle finestre Autos e Locals.
c) Durante il debugging il comando Step Out esegue le istruzioni rimanenti nella funzione corrente e restituisce il controllo
del programma al punto in cui la funzione era stata richiamata.
Risposte agli esercizi di autovalutazione
F.1
a) break mode. b) Quick Info box. c) Watch. d) Step Over.
F.2
a) Falso. Quando l'esecuzione del programma viene sospesa in corrispondenza di un breakpoint, il prossimo comando da
eseguire è il comando corrispondente al breakpoint. b) Falso. Una variabile diventa rossa se il suo valore è stato modificato. c) Vero.
Copyright (C) 2010 Apogeo