Debug del tuo programma

Debug del tuo programma
Debug del tuo programma
Ritengo che questo sia un argomento che deve essere trattato in dettaglio. Così com'è, il debug è una parte incredibilmente importante della programmazione. Se si verificano errori, è necessario sapere come trovare il problema e risolverlo. Se ti manca un punto e virgola, non dovresti scrivere un post per capirlo.
Tieni presente che questo non è specificamente il modo in cui dovresti eseguire il debug. Non è un insieme di regole, è un insieme di consigli. I miei consigli potrebbero non essere necessariamente una pratica corretta. Se in questo articolo viene trovato qualcosa di errato, per favore pubblicalo in modo che possa risolverlo. Non mi piace diffondere false conoscenze.

Ad ogni modo, inizieremo di base, dal riconoscimento e dalla comprensione di un errore del compilatore, al passaggio singolo attraverso un programma con il debugger del tuo IDE.

Nota:sto facendo riferimento a C++ per Dummies 5th Edition di Stephen Randy Davis, pagine 139-155.

Identificazione di un errore
Spesso il tuo programma non funziona come previsto e non verrà compilato correttamente. Anche i migliori programmatori commettono errori, essere in grado di identificare cosa hai sbagliato è essenziale. Esistono due tipi di errori; quelli che il compilatore C++ può catturare da solo e quelli che il compilatore non può catturare. Gli errori che C++ può rilevare sono noti come errori in fase di compilazione. Gli errori in fase di compilazione dovrebbero essere relativamente facili da correggere, perché il compilatore indica dove si trova il problema. Tutta quella spazzatura sputata dal compilatore ha una qualche utilità. Ecco un esempio. Ho dimenticato di mettere un punto e virgola dopo la mia dichiarazione di reso.
1
2
3
4
int main()
{
return 0
}

Il tuo compilatore dovrebbe generare un errore simile a...
\main.cpp(4) : error C2143: syntax error : missing ';' before '}' Gli errori del compilatore differiscono da compilatore a compilatore, ma generalmente saranno tutti uguali. Nel mio caso, sto usando Visual Studio 2008, ma se stai usando Dev-C++ o G++, vale la stessa cosa.
Ora prendiamo a parte questo errore del compilatore. La prima parte \main.cpp(4) dice che l'errore è nel file main.cpp, alla riga 4. Dopo è error C2143: Questo è il codice di errore specifico del compilatore. Se stai usando Visual Studio, puoi facilmente cercare il codice di errore su MSDN, se necessario. Dopodiché l'errore indica syntax error : Il che ti dice che hai incasinato un po' di sintassi. Quindi non devi aver digitato qualcosa di giusto. Poi mi dice missing ‘;’ before ‘}’ C'è un punto e virgola mancante prima di una parentesi di chiusura. Ok, quindi so che mi manca un punto e virgola, so che l'errore è sulla riga 4, so che è prima della parentesi di chiusura. Quindi vado su main.cpp, riga 4, e prima della parentesi di chiusura ho bisogno di un punto e virgola. Poiché l'unica cosa che è sulla riga 4 è una parentesi di chiusura, salirò solo alla riga tre e OH! Ho notato che ho dimenticato di mettere un punto e virgola dopo return 0 . Riconoscere un errore del compilatore dovrebbe essere così facile.
L'altro tipo di errore che C++ non rileva è chiamato errore di runtime. Gli errori di runtime sono spesso molto più difficili da rilevare.

Tecniche di debug
Esistono diversi modi per eseguire il debug di un programma. I due che uso più spesso sono la tecnica WRITE e il debug a passaggio singolo. In primo luogo, tratterò la tecnica SCRITTURA. Implica la creazione di istruzioni di output per tutte le tue variabili, in modo da poter vedere il valore di tutto. Userò questo esempio di programma da C++ per Dummies 5a edizione.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
// ErrorProgram – This program averages a series
//		 of numbers, except that it contains
//		 a fatal bug.
#include <cstdio>
#include <cstdlib>
#include <iostream>
using namespace std;

int main(int nNumberofArgs, char *pszArgs[])
{
	cout << "This program is designed to crash!"
		 << endl;

	int nSum;
	int nNums;

	// accumulate input numbers until the
	// user enteres a negative number, then
	// return the average
	nNums = 0;
	while(true)
	{
		// enter another number to add
		int nValue;
		cout << "Enter another number:";
		cin >> nValue;
		cout << endl;

		// if the input number is negative...
		if(nValue < 0)
		{
			// ... then output the average
			cout << "Average is: "
				 << nSum/nNums
				 << endl;
			break;
		}

		// not negative, add the value to
		// the accumulator
		nSum += nValue;
	}

	cin.ignore(10000, '\n');
	return 0;
}


Quando esegui questo codice, riceverai un errore di runtime. Un modo semplice per risolvere ciò che è incasinato è usare la tecnica SCRITTURA. Ogni volta che entri nel ciclo while, fai in modo che emetta il valore di nNums.

1
2
3
4
5
6
7
While(true)
{
	// output
	cout << “nNums = “ << nNums << endl;
	
	// The rest of the program is unchanged
}


L'output sarà simile

This program is designed to crash!
nNums = 0
Enter another number:1

nNums = 0
Enter another number:2

nNums = 0
Enter another number:3

nNums = 0 
Enter another number:

Puoi vedere che nNums viene inizializzato su 0, ma dove viene incrementato? Non lo è, e questo è il bug. Chiaramente nNums avrebbe dovuto essere incrementato durante ogni ciclo della sezione di input. Usando la tecnica WRITE, abbiamo detto al programma di produrre il valore di nNums ad ogni ciclo, scoprendo così che non veniva incrementato correttamente.

Per programmi più piccoli, la tecnica WRITE funziona abbastanza bene, ma man mano che le cose si ingrandiscono, è più difficile produrre tutte le variabili e inizia a sembrare una perdita di tempo. Invece, faremo affidamento sul debugger. Innanzitutto, definiamo un debugger. Un debugger è uno strumento integrato nella maggior parte degli ambienti di sviluppo (e sebbene differiscano, la maggior parte dei debugger funziona secondo gli stessi principi). Un programmatore controlla il debugger tramite comandi tramite la stessa interfaccia dell'editor. È possibile accedere a questi comandi nelle voci di menu o utilizzando i tasti di scelta rapida. Il debugger consente al programmatore di controllare l'esecuzione del proprio programma. Può eseguire un passaggio alla volta nel programma, può interrompere il programma in qualsiasi momento e può esaminare il valore delle variabili. Per apprezzare la potenza del debugger, devi vederlo in azione. L'uso di questo è difficile da spiegare a parole (e sono terribile nel mettere le cose in parole). Quindi, per ulteriori informazioni sul debug, ti collegherò a una pagina Web molto utile. http://www.cprogramming.com/tutorial/debugging_concepts.html

Se c'è qualcosa che deve essere aggiunto, fammi sapere.