Introduzione alla programmazione

Lezione 8

Il controllo degli errori

Avere il controllo degli errori significa avere un software stabile anche in caso di errori, errori che possono dipendere dalle interazioni dell’utente o da sviste di programmazione.
Vediamo subito come catturare gli errori e impedire il crash del nostro programma:

  procedure TForm1.Button1Click(Sender: TObject);
    var
      I,A,R:integer;
  begin
    I:=100;
    A:=0;
    R:=I div A;
    ShowMessage(IntToStr(R));
  end;

N.B.
Questa procedura darà un errore che bloccherà l’esecuzione del programma, abbiamo creato un errore irreversibile andando a dividere un numero per zero!

In matematica un qualsiasi numero diviso zero da un risultato non congruo, non "scrivibile" con una variabile integer. Ma non stiamo a sottilizzare, tanto nel nostro integer quel risultato non ci entrerà mai!
Ecco come si procede per una corretta gestione degli errori, errori che prendono il nome di eccezioni nel linguaggio informatico:

  procedure TForm1.Button13Click(Sender: TObject);
    var
      I,A,R:integer;
  begin
    I:=100;
    A:=0;
    Try
      R:=I div A;
      ShowMessage(IntToStr(R));
    Except
      on EDivByZero do
        ShowMessage ('Si è verificato un errore: hai diviso per zero!');
    end;
  end;

N.B.
Mettiamo il codice che potrebbe dare un errore tra le parole Try ed Except, se si verifica un errore viene eseguito il codice dopo Except (fino al suo end;) e viene ignorato il codice tra il punto in cui si è generato l’errore e la parola Except…

Oltre al "Try Except" esiste anche il "Try Finally" che si usa quando non serve tanto sapere che errore si è generato, ma piuttosto per impedire il crash del programma e per essere sicuri di compiere le ultime azioni prima di uscire dalla funzione o procedura.
Si usa, di solito, quando abbiamo creato degli oggetti che devono essere distrutti prima di uscire dalla procedura per non lasciare sporcizia nella memoria del PC.
Questo sistema lo vedremo dopo aver imparato a creare oggetti tramite il codice anziché metterli nel form durante la progettazione.

Creare un oggetto a Run Time

A volte è necessario avere un oggetto da usare in una procedura ma non è necessario averlo sempre sul form a prendere posto e risorse, quindi possiamo crearlo grazie al codice che scriviamo proprio nel momento esatto in cui ci servirà.
In un linguaggio di programmazione esistono anche oggetti che non possono essere usati o piazzati sul form ma possono solo essere creati al momento in cui se ne abbia bisogno.

Usiamo uno di questi oggetti utilizzabili solo a run time (ricordi cosa vuol dire a run time?):

  procedure TForm1.Button13Click(Sender: TObject);
    var
      S:TstringList;
      I:Integer;
      R:String;
  begin
    S:=TstringList.Create;
    try
      S.LoadFromFile(ExtractFilePath(Application.ExeName)+/lista.txt');
      R:='';
      For I:=0 To S.Count-1 do
        R:=R+S[I]+Chr(10);
    finally
      S.Free;
    end;
    ShowMessage(R);
  end;

N.B.
In questo esempio creiamo una TstringList che è un contenitore di stringhe, queste stringhe possono essere aggiunte con il metodo Add (aggiungi), o possono essere caricate da un file di testo in cui ogni riga rappresenta una stringa.

La creazione è molto semplice, si dichiara la variabile (in questo caso S) e poi si crea con S:=TstringList.Create;
Un oggetto creato in questo modo deve essere distrutto prima di uscire dalla procedura che l’ha creato, questa distruzione dovrebbe avvenire sempre, e anche se vi sono casi in cui se ne potrebbe fare a meno, è comunque una buona abitudine disfarsi della spazzatura.
Dopo averlo creato e prima che il comando S.Free possa distruggerlo, il programma potrebbe incorrere in un errore, allora per essere certi di distruggere l’oggetto, qualsiasi cosa accada, dobbiamo scrivere il comando di distruzione tra finally e end; avendo avuto cura di scrivere Try subito dopo aver creato l’oggetto (è ok anche scriverlo prima).
Ciò che scriviamo tra "Finally" e il suo "end" verrà eseguito anche in caso di errore!

Adesso prova ad eseguire questa procedura, otterrai un errore (il file lista.txt non è stato trovato), ma stanne certo, la TstringList sarà stata distrutta lo stesso.

Segui ora le mie istruzioni:
Crea un file di testo e scrivici dentro un elenco di animali, uno per ogni riga del file di testo, salvalo dentro alla cartella in cui hai salvato il sorgente del programma che stai scrivendo, salvalo come “lista.txt”.
Ora esegui di nuovo il programma, ma prima, se stai usando Windows cambia la stringa “/lista.txt” nel codice con la stringa “\lista.txt”, infatti Windows utilizza la barra inversa rispetto agli altri sistemi operativi.
Se invece usi Linux, BSD, Mac, Unix o qualsiasi altro Sistema Operativo sei già a posto così.

Ecco che adesso ti appare la lista così come scritta nel file. La procedura è finita e visto che la TstringList non era più necessaria è stata distrutta.

Gli oggetti creati hanno proprietà e metodi, proprio come quelli che puoi disporre graficamente sul form mentre disegni la tua finestra.
Usiamo una proprietà a caso di un oggetto creato in questo esempio (usa lo stesso progetto dell'esempio precedente aggiungendo un nuovo oggetto button):

  procedure TForm1.Button14Click(Sender: TObject);
    var
      S:TstringList;
      I:Integer;
      R:String;
  begin
    S:=TstringList.Create;
    Try
      S.LoadFromFile(ExtractFilePath(Application.ExeName) + '/lista.txt');
      S.Sorted:=True;
      R:='';
      For I:=0 To S.Count-1 do
        R:=R+S[I]+Chr(10);
    finally
      S.Free;
    end;
    ShowMessage(R);
  end;

Come vedi ho aggiunto la riga S.Sorted:=True;
Ho assegnato la proprietà sorted (ordinato) così che le stringhe di testo nella TstringList venissero ordinate alfabeticamente.
Adesso, eseguendo il programma, vedrai i tuoi animali in ordine alfabetico. Avremo potuto ottenere lo stesso risultato usando un metodo della TstringList chiamando S.Sort;
In questo esempio abbiamo quindi visto anche il controllo degli errori di cui parlavamo poco più su.

Esercitati con questo e buon divertimento.

Sommario