Diciamo che abbiamo una funzione come questa:
public void myStart()
{
for (int i = 0; i<10; i++) myFunction(i);
}
private int myFunction(int a)
{
a = foo(a);
a = bar(a);
return a;
}
private int foo(int a)
{
//do something here
//something gnarly here
//etc
return aValue;
}
private int bar(int a)
{
// do something here
//return aValue;
}
Ora, per qualsiasi motivo, il nostro codice non funziona. Forse sta generando un errore, forse sta restituendo un valore sbagliato, forse è bloccato in un ciclo infinito.
La prima cosa che ogni programmatore del primo anno è stampare su console / std, (avendo imparato a stampare Hello World prima di imparare a usare un debugger).
Ad esempio, per eseguire il debug di questo codice potrebbero eseguire le seguenti operazioni:
private int myFunction(int a)
{
print("before foo: a=" + a);
a = foo(a);
print("before bar: a=" + a);
a = bar(a);
return a;
}
private int foo(int a)
{
//do something here
print ("foo step1: a=" + a);
//something gnarly here
print ("foo step2: a=" + a + " someOtherValue="+ someOtherValue + " array.length= " + someArray.length());
//etc
return aValue;
}
private int bar(int a)
{
// do something here
//return aValue;
}
Ora eseguono il codice, ottengono una grande console di stampa, che possono passare per rintracciare dove le cose vanno male.
Un'alternativa, ovviamente, è impostare punti di interruzione e scorrere il codice in ogni punto.
Uno dei principali vantaggi della stampa su console è che lo sviluppatore può vedere il flusso dei valori in una volta sola, senza dover fare clic su passaggi ecc.
Ma lo svantaggio è che il tuo codice è quindi pieno di tutte queste istruzioni di stampa che devono essere rimosse.
(È forse possibile dire al debugger di stampare solo determinati valori su un registro? I punti di interruzione possono quindi essere facilmente aggiunti o rimossi senza modificare effettivamente il codice.)
Uso ancora la stampa da console come metodo di debug primario, mi chiedo quanto sia comune / efficace rispetto a qualcos'altro là fuori.