Esercitazione: Informazioni sul debug del codice C++ tramite Visual Studio

Articolo
05/08/2023

Questo articolo descrive le funzionalità del debugger di Visual Studio con una procedura dettagliata. Per una panoramica di alto livello delle funzionalità del debugger, vedere Presentazione del debugger. Quando si esegue il debug dell'app in genere si esegue l'applicazione con il debugger collegato. Durante il debug, il debugger offre diversi modi per vedere le operazioni eseguite dal codice durante l'esecuzione. È possibile rivedere il codice ed esaminare i valori archiviati nelle variabili, impostare espressioni di controllo nelle variabili per rilevare le modifiche dei valori, esaminare il percorso di esecuzione del codice, verificare l'esecuzione di un ramo del codice e così via. Se è la prima volta che si esegue il debug del codice, può essere utile leggere Debug per principianti prima di procedere con questo articolo.

Anche se l'app demo è C++, la maggior parte delle funzionalità è applicabile a C#, Visual Basic, F#, Python, JavaScript e altri linguaggi supportati da Visual Studio (F# non supporta Modifica e continuazione). F# e JavaScript non supportano la finestra Auto . Gli screenshot sono in C++.

Questa esercitazione illustra come:

Avvio del debugger e raggiungimento dei punti di interruzione
Uso dei comandi per esaminare il codice nel debugger
Ispezione delle variabili nelle finestre dei suggerimenti dati e del debugger
Analisi dello stack di chiamate

Prerequisiti

Visual Studio deve essere installato e il carico di lavoro Sviluppo di applicazioni desktop con C++ .

Se non è ancora stato installato Visual Studio, accedere alla pagina Download di Visual Studio per installarlo gratuitamente.

Se Visual Studio 2022 non è già stato installato, passare alla pagina dei download di Visual Studio 2022 per installarlo gratuitamente.

Se occorre installare il carico di lavoro, ma si ha già Visual Studio, passare a Strumenti>Ottieni strumenti e funzionalità, che apre il programma di installazione di Visual Studio. Verrà avviato il Programma di installazione di Visual Studio. Selezionare il carico di lavoro Sviluppo di applicazioni desktop con C++, quindi scegliere Modifica.

Creare un progetto

Prima di tutto, si creerà un progetto di applicazione console C++. Il tipo di progetto include fin dall'inizio tutti i file modello necessari.

Aprire Visual Studio.

Se la finestra iniziale non è aperta, scegliere Finestra di avvio file>.
Nella finestra iniziale scegliere Crea un nuovo progetto.
Nella finestra Crea un nuovo progetto immettere o digitare console nella casella di ricerca. Scegliere quindi C++ dall'elenco Linguaggio e quindi scegliere Windows dall'elenco Piattaforma.

Dopo aver applicato i filtri lingua e piattaforma, scegliere il modello App console e quindi scegliere Avanti.

Nota

Se non viene visualizzato il modello app console, è possibile installarlo dalla finestra Crea un nuovo progetto . Nel messaggio L'elemento cercato non è stato trovato? scegliere il collegamento Installa altri strumenti e funzionalità. Quindi, nella Programma di installazione di Visual Studio scegliere il carico di lavoro Sviluppo di applicazioni desktop con C++.
Nella finestra Configura il nuovo progetto digitare o immettere get-started-debugging nella casella Nome progetto. Scegliere Crea.

Visual Studio aprirà il nuovo progetto.

Creare l'applicazione

In get-started-debugging.cpp sostituire invece tutto il codice predefinito con il codice seguente:

#include <string>
#include <vector>
#include <iostream>

void SendMessage(const std::wstring& name, int msg)
{
    std::wcout << L"Hello, " << name << L"! Count to " << msg << std::endl;
}

int main()
{
    std::vector<wchar_t> letters = { L'f', L'r', L'e', L'd', L' ', L's', L'm', L'i', L't', L'h' };
    std::wstring name = L"";
    std::vector<int> a(10);
    std::wstring key = L"";

    for (int i = 0; i < letters.size(); i++)
    {
        name += letters[i];
        a[i] = i + 1;
        SendMessage(name, a[i]);
    }
    std::wcin >> key;
    return 0;
}

Avviare il debugger.

Premere F5 (Debug > Avvia debug) o il pulsante Avvia debug sulla barra degli strumenti debug.

F5 avvia l'app con il debugger collegato al processo dell'app. Fino ad ora, tuttavia, non è stata eseguita alcuna operazione per esaminare il codice. Di conseguenza, viene semplicemente avviata l'app e viene visualizzato l'output della console.
```
Hello, f! Count to 1
Hello, fr! Count to 2
Hello, fre! Count to 3
Hello, fred! Count to 4
Hello, fred ! Count to 5
Hello, fred s! Count to 6
Hello, fred sm! Count to 7
Hello, fred smi! Count to 8
Hello, fred smit! Count to 9
Hello, fred smith! Count to 10
```
In questa esercitazione viene esaminata l'app usando il debugger e vengono descritte le funzionalità del debugger.
Arrestare il debugger premendo il pulsante di arresto rosso (MAIUSC + F5).
Nella finestra della console premere un tasto e INVIO per chiudere la finestra della console.

Impostare un punto di interruzione e avviare il debugger

Nel ciclo for della funzione main impostare un punto di interruzione facendo clic sul margine sinistro della riga di codice seguente:

name += letters[i];

Viene visualizzato un cerchio rosso in cui si imposta il punto di interruzione.

I punti di interruzione sono una delle funzionalità di base e essenziali del debug affidabile. Un punto di interruzione indica il punto in cui Visual Studio dovrebbe sospendere l'esecuzione del codice in modo da poter esaminare i valori delle variabili, il comportamento della memoria o lo stato di esecuzione di un ramo del codice.
Premere F5 o il pulsante Avvia debug , l'app viene avviata e il debugger viene eseguito sulla riga di codice in cui si imposta il punto di interruzione.

La freccia gialla rappresenta l'istruzione in cui il debugger è in pausa e in cui viene anche sospesa l'esecuzione di app (l'istruzione non è ancora stata eseguita).

Se l'app non è ancora in esecuzione, F5 avvia il debugger e lo arresta in corrispondenza del primo punto di interruzione. In caso contrario, F5 continua l'esecuzione dell'app fino al punto di interruzione successivo.

I punti di interruzione sono una funzionalità utile quando si conosce la riga di codice o la sezione di codice che si vuole esaminare nel dettaglio. Per informazioni sui diversi tipi di punti di interruzione che è possibile impostare, ad esempio i punti di interruzione condizionali, vedere Uso di punti di interruzione.

Esplorare il codice nel debugger tramite i comandi di esecuzione

In questa esercitazione nella maggior parte dei casi vengono usati tasti di scelta rapida che rappresentano un modo rapido per eseguire l'app nel debugger (i comandi equivalenti, ad esempio i comandi di menu, sono indicati tra parentesi).

Mentre è in pausa nel for ciclo nel main metodo, premere F11 (o scegliere Esegui istruzione di debug>) due volte per passare alla chiamata al SendMessage metodo.

Dopo aver premuto F11 due volte, si dovrebbe trovarsi in questa riga di codice:

SendMessage(name, a[i]);
Premere F11 un'altra volta per eseguire l'istruzione nel SendMessage metodo .

Il puntatore giallo avanza nel SendMessage metodo .

F11 corrisponde al comando Esegui istruzione e consente di eseguire l'app un'istruzione alla volta. F11 è un buon metodo per esaminare il flusso di esecuzione nel dettaglio. Per spostarsi più velocemente nel codice, vengono visualizzate anche alcune altre opzioni. Per impostazione predefinita, il debugger ignora il codice non utente (se si vogliono altri dettagli, vedere Just My Code).

Si supponga di aver completato l'analisi del SendMessage metodo e di voler uscire dal metodo, ma rimanere nel debugger. Questa operazione può essere eseguita usando il comando Esci da istruzione/routine.
Premere MAIUSC + F11 (o Esegui debug > istruzione/routine).

Questo comando riprende l'esecuzione dell'app (e avanza il debugger) fino a quando non viene restituito il metodo o la funzione corrente.

Si dovrebbe tornare al for ciclo nel main metodo, sospeso alla chiamata al SendMessage metodo.
Premere F11 più volte finché non si torna alla chiamata al SendMessage metodo.
Mentre è in pausa alla chiamata al metodo, premere F10 (o scegliere Esegui debug > passaggio) una sola volta.

Si noti questa volta che il debugger non esegue l'istruzione nel SendMessage metodo . F10 fa avanzare il debugger senza eseguire le istruzioni nelle funzioni o nei metodi del codice dell'app (il codice rimane in esecuzione). Premendo F10 nella chiamata al metodo SendMessage anziché F11, è stato ignorato il codice di implementazione per SendMessage (non d'interesse ai fini dell'esercitazione). Per altre informazioni sui diversi modi per spostarsi nel codice, vedere Esplorare il codice nel debugger.

Esplorare il codice con il pulsante per l'esecuzione fino alla riga selezionata dall'utente

Premere F5 per passare al punto di interruzione.
Nell'editor di codice scorrere verso il basso e passare il puntatore del mouse sulla std::wcout funzione nel metodo fino a visualizzare il pulsanteverde Esegui fino a fare clic a SendMessage sinistra. La descrizione comando per il pulsante è "Continua l'esecuzione fino a qui".

Nota

Il pulsante Esegui a clic è una novità di Visual Studio 2017. Se non viene visualizzato il pulsante freccia verde, usare F11 in questo esempio per spostare il debugger nella posizione corretta.
Fare clic sul pulsante Esegui per fare clic su .

Il debugger passa alla std::wcout funzione.

L'uso di questo pulsante è simile all'impostazione di un punto di interruzione temporaneo. Il pulsante per l'esecuzione fino alla riga selezionata dall'utente è uno strumento pratico per l'esplorazione rapida all'interno di un'area visibile del codice dell'app (è possibile fare clic in qualsiasi file aperto).

Riavviare rapidamente l'app

Fare clic sul pulsante Riavvia nella barra degli strumenti debug (CTRL + MAIUSC + F5).

Il pulsante Riavvia consente di risparmiare tempo rispetto all'arresto dell'app e al riavvio del debugger. Il debugger viene messo in pausa in corrispondenza del primo punto di interruzione raggiunto eseguendo il codice.

Il debugger si arresta di nuovo nel punto di interruzione impostato in precedenza all'interno del for ciclo.

Esaminare le variabili con i suggerimenti dati

Le funzionalità che consentono di esaminare le variabili sono tra le funzionalità più utili del debugger e sono disponibili diversi modi per eseguire questa operazione. Spesso quando si tenta di eseguire il debug di un problema, si tenta di determinare se le variabili includono i valori previsti in un determinato momento.

Mentre è in pausa sull'istruzione name += letters[i] , passare il puntatore del mouse sulla letters variabile e viene visualizzato il valore predefinito, size={10}.
Espandere la letters variabile per visualizzarne le proprietà, che includono tutti gli elementi contenuti nella variabile.
Passare quindi il puntatore del mouse sulla variabile e visualizzarne il name valore corrente, una stringa vuota.
Premere F5 (o Debug>Continua) alcune volte per scorrere più volte il for ciclo, sospendere nuovamente il punto di interruzione e passare il puntatore del mouse sulla variabile ogni volta per controllarne il name valore.

Il valore della variabile cambia con ogni iterazione del for ciclo, mostrando i valori di f, quindi fr, e frecosì via.

Spesso, durante il debug, è necessario controllare rapidamente i valori delle proprietà sulle variabili, per vedere se si stanno archiviando i valori previsti, e i suggerimenti dati costituiscono un valido strumento per questa operazione.

Esaminare le variabili con le finestre Auto e Variabili locali

Osservare la finestra Auto nella parte inferiore dell'editor di codice.

Se è chiusa, aprirla mentre è in pausa nel debugger scegliendo Debug>Finestre>Auto.

Nella finestra Auto vengono visualizzate le variabili e i relativi valori correnti. La finestra Auto mostra tutte le variabili usate nella riga corrente o nella riga precedente (vedere la documentazione per il comportamento specifico del linguaggio).
Osservare quindi la finestra Variabili locali in una scheda accanto alla finestra Auto.
Espandere la letters variabile per visualizzare gli elementi contenuti.

La finestra Variabili locali mostra le variabili presenti nell'ambito corrente, ovvero il contesto di esecuzione corrente.

Impostare un'espressione di controllo

Nella finestra dell'editor di codice principale fare clic con il pulsante destro del mouse sulla name variabile e scegliere Aggiungi espressione di controllo.

Viene visualizzata la finestra Espressione di controllo nella parte inferiore dell'editor di codice. È possibile usare una finestra Espressione di controllo per specificare una variabile (o un'espressione) che si vuole controllare.

A questo punto, è presente un watch impostato sulla name variabile ed è possibile visualizzarne la modifica del valore durante lo spostamento nel debugger. A differenza di altre finestre delle variabili, la finestra Espressione di controllo mostra sempre le variabili controllate (che appaiono disattivate quando sono fuori ambito).

Analisi dello stack di chiamate

Mentre l'esecuzione è in pausa nel ciclo for, fare clic sulla finestra Stack di chiamate, visualizzata per impostazione predefinita nel riquadro inferiore destro.

Se è chiusa, aprirla mentre è in pausa nel debugger scegliendo Debug>Finestre>Stack di chiamate.
Fare clic su F11 alcune volte fino a quando non viene visualizzata la sospensione del debugger nel SendMessage metodo . Osservare la finestra Stack di chiamate.

La finestra Stack di chiamate visualizza l'ordine in cui vengono chiamati metodi e funzioni. La prima riga visualizza la funzione corrente (il metodo SendMessage in questa app). La seconda riga indica che SendMessage è stato chiamato dal metodo main e così via.

Nota

La finestra Stack di chiamate è simile alla prospettiva di debug di alcuni IDE come Eclipse.

Lo stack di chiamate è un ottimo modo per esaminare e comprendere il flusso di esecuzione di un'app.

È possibile fare doppio clic su una riga di codice per visualizzare il codice sorgente e modificare anche l'ambito corrente controllato dal debugger. Questa azione non fa avanzare il debugger.

È anche possibile usare i menu di scelta rapida dalla finestra Stack di chiamate per eseguire altre operazioni. Ad esempio, è possibile inserire i punti di interruzione nelle funzioni specificate, far avanzare il debugger usando Esegui fino al cursore e passare a esaminare il codice sorgente. Per altre informazioni, vedere Procedura: Esaminare lo stack di chiamate.

Modificare il flusso di esecuzione

Premere F11 due volte per eseguire la std::wcout funzione.
Con il debugger sospeso nella chiamata al SendMessage metodo, usare il mouse per afferrare la freccia gialla (il puntatore di esecuzione) a sinistra e spostare la freccia gialla verso l'alto di una riga, tornare a std::wcout.
Premere F11.

Il debugger esegue di nuovo la std::wcout funzione (viene visualizzata nell'output della finestra della console).

Modificando il flusso di esecuzione è possibile eseguire operazioni come testare percorsi di esecuzione del codice diversi o rieseguire il codice senza riavviare il debugger.

Avviso

Spesso questa funzionalità deve essere usata con attenzione. Nella descrizione comando viene visualizzato un avviso. È anche possibile che vengano visualizzati altri avvisi. Non è possibile ripristinare uno stato precedente dell'applicazione spostando il cursore.
Premere F5 per continuare a eseguire l'app.

L'esercitazione è stata completata.

Passaggi successivi

In questa esercitazione si è appreso come avviare il debugger, eseguire il codice ed esaminare le variabili. Sono disponibili una panoramica delle funzionalità del debugger e collegamenti a ulteriori informazioni.

Presentazione del debugger