Pascal/Metodo top-down, procedure e funzioni

Per metodo top-down si intende una suddivisione di un problema, di un algoritmo o di un procedimento in sottoproblemi più piccoli e più semplici da implementare nel linguaggio desiderato.
Una delle comodità della scomposizione dei problemi in porzioni di codice è la loro riutilizzabilità: tramite il metodo top-down, infatti, il programmatore può definire blocchi di codice a cui è possibile fare riferimento durante il corso della programmazione.

In Pascal possiamo implementare soluzioni top-down tramite le procedure e le funzioni.

Procedure

Per procedura si intende una porzione di codice riutilizzabile che può prevedere parametri in ingresso ma non prevede parametri in uscita. La sua sintassi è:

procedure nome_procedura(variabili_richieste_come_parametri);
dichiarazioni
begin
istruzioni;
end;

Le diverse procedure del programma Pascal devono essere scritte prima del blocco begin...end; che delimita il programma principale. Vediamo un esempio completo di un sottoproblema implementato in Pascal come, ad esempio, dare il benvenuto ad un utente, all'interno di un programma più lungo che ometteremo:

program Esempio;

    var [...]

    
    procedure Benvenuto;
        var nome:string[50];
    begin
        writeln('Come ti chiami?');
        readln(nome);
        writeln('Benvenuto su it.wikibooks, ', nome);
    end;


(* qui incomincia il programma vero *)
begin
    (* centinaia righe di codice... *)
    (* in questa riga viene ''chiamata'' (o ''invocata'') la procedura Benvenuto *)
    (* e viene eseguita la porzione di codice in essa contenuta *)
    Benvenuto;
    (* centinaia righe di codice... *)
end.

In questo semplice caso la procedura Benvenuto chiede un input all'utente e stampa un messaggio di benvenuto.
La comodità di questo semplice spezzone sta nel fatto che, durante l'esecuzione del programma vero e proprio, in qualsiasi punto è possibile eseguire la procedura Benvenuto quante volte si vuole riducendo così la mole di codice da scrivere e anche facilitando, ad esempio, la correzione di eventuali errori o la revisione del codice.
Questo metodo è ovviamente comodo nel caso di programmi molto lunghi o di sottoproblemi che si ripresentino molte volte nel corso del programma

Le variabili usate nella procedura e dichiarate quindi nella sezione di dichiarazione della procedura stessa (nel nostro esempio la variabile nome) sono chiamate variabili locali, in quanto non è possibile richiamarle se non dalla procedura nelle quali sono dichiarate. Nel programma vero e proprio e nelle procedure le variabili locali delle altre eventuali procedure non sono quindi utilizzabili.
Sono chiamate variabili globali le variabili dichiarate all'intestazione del programma principale, in quanto possono essere richiamate e utilizzate sia in ambito del programma principale stesso sia in ambito locale delle procedure.
Si noti che nel caso che due variabili con lo stesso nome sono dichiarate sia in ambito globale che in ambito locale, nelle procedure il compilatore prende in considerazione la variabile locale. Il consiglio è comunque quello di dare nomi sempre diversi alle variabili, evitando sovrapposizioni di qualsiasi genere.
Un esempio potrebbe rendere il tutto più chiaro:

program Variabili;

    var principale:integer;
  
  
    procedure proc1;
        var locale1:integer;
    begin
        (* da qui sono accessibili solo le variabili ''locale1'' e ''principale''*)
    end;


    procedure proc2;
        var locale2:integer;
    begin
        (* da qui sono accessibili solo le variabili ''locale2'' e ''principale''*)
    end;


(* qui incomincia il programma vero *)
begin
    (* da qui è accessibile solo la variabile ''principale''*)
end.

Procedure con argomenti

Può risultare utile, in molti casi, passare alla procedura dei valori che specifichino meglio l'operazione da svolgere o che ne rendano l'uso più utile alle diverse situazioni. Questi valori sono detti argomenti o parametri Nell'esempio precedente, ad esempio, sarebbe meglio poter specificare ogni volta il messaggio stampato dalla procedura Benvenuto in modo tale da renderla utilizzabile in più situazioni. Vediamo l'esempio con l'uso delle variabili:

program Esempio;

    var [...]


    procedure Benvenuto (domanda, risposta: string[100]);
        var nome:string[50];
    begin
        writeln(domanda);
        readln(nome);
        writeln(risposta, nome);
    end;


(* qui incomincia il programma vero *)
begin
    (* centinaia righe di codice... *)
    Benvenuto('Qual è il tuo nome?', 'Benvenuto nel mio sito, ');
    (* centinaia righe di codice... *)
    Benvenuto('Come si chiama la tua fidanzata?', 'Salutami allora ');
end.

In questo caso la procedura Benvenuto è stata chiamata due volte nel corso del programma passando ogni volta i due argomenti richiesti, che non sono altro che delle espressioni che verranno poi salvate nelle variabili domanda e risposta. L'output delle due procedure sarà il seguente, nel caso l'input sia Luigi o Luisa:

Qual è il tuo nome? Luigi
Benvenuto nel mio sito, Luigi

Come si chiama la tua fidanzata? Luisa
Salutami allora Luisa

I parametri sono ovviamente variabili locali della procedura.

Passaggio di parametri per valore e per riferimento

Introdotto l'uso dei parametri, è necessario però fare una distinzione molto importante tra i due modi possibili di passare una variabile:

• quando i valori sono passati per valore la variabile che funge da parametro assume semplicemente il valore dell'espressione introdotta nella chiamata della procedura. Questa è la situazione presentata nel programma Esempio che abbiamo precedentemente visto.
• quando i valori sono passati per riferimento la variabile che funge da parametro si sostituisce momentanemente alla variabile passata nella chiamata della procedura, che verrà quindi modificata nel corso del programma. In questo caso il parametro deve essere indicato con la sintassi var nome_var : tipo di dato;

La differenza sarà forse più chiara con un esempio:

program Esempio;

    var z1, z2:real;


    procedure Valore (x:real);
    begin
        x := 2*x;
        writeln('Il valore di X è ', x);
    end;


    procedure Riferimento (var x:real);
    begin
        x := 2*x;
        writeln('Il valore di X è ', x);
    end;


(* qui incomincia il programma vero *)
begin
    z1 := 5;
    z2 := 12;
    Valore(z1);
    Riferimento(z2);
    writeln('Il valore di z1 è ',z1);
    writeln('Il valore di z2 è ',z2);
end.

Dopo l'esecuzione del programma, avremo quindi la seguente situazione:

• il valore di z1 sarà rimasto lo stesso di quando la procedura è stata invocata, in quanto il passaggio del parametro x è avvenuto per valore. Al posto di z1 si poteva passare alla procedura anche un'espressione, come 3 + 4 o anche z1 + 5.
• il valore di z2 dopo la chiamata della procedura Riferimento sarà pari a 24, ossia 12 * 2, in quanto il parametro x è stato passato per riferimento e, quindi, al momento dell'istruzione x := x*2 non varia solo la variabile x stessa all'interno della procedura ma anche il valore della variabile z2.

L'output del programma sarà quindi:

Il valore di X è 10
Il valore di X è 24
Il valore di z1 è 5
Il valore di z2 è 24

Funzioni

Il concetto di funzioni in programmazione è strettamente legato al concetto di funzione matematica. In Pascal possiamo pensare ad una funzione come ad una procedura che restituisce un valore: le funzioni, come le procedure, devono essere dichiarate prima del programma principale e possono disporre di variabili locali e di parametri.

La loro sintassi è tuttavia leggermente diversa:

function nome_della_funzione(parametri):tipo_di_dato_restituito_dalla_funzione;
dichiarazioni
begin
istruzioni;
end

Per riferirsi al valore della funzione si deve fare riferimento al nome della funzione stessa. Creiamo ad esempio una funzione che restituisca il valore assoluto di un numero:

function Assoluto (x:real):real;
begin
    if x<0 then
     Assoluto := -x
    else
     Assoluto := x;
end;

Analizziamo il listato riga per riga:

1. la prima riga è la dichiarazione della funzione, che richiede un parametro real, x, e che restituisce un valore real
2. inizio della funzione (non ci sono variabili da dichiarare in questo caso perché la funzione è molto semplice)
3. se x è minore di zero allora
4. restituisci come valore l'opposto di x
5. altrimenti (x maggiore o uguale a 0)
6. restituisci il valore di x
7. fine della funzione

In questo modo, passando alla funzione 3, Assoluto restituisce 3, mentre se si passa -12 la funzione restituisce 12. È possibile in qualsiasi punto del programma in cui la funzione è stata inserita ricorrere ad essa usando la seguente notazione:

Assoluto(n);

che funge da espressione in quanto restituisce un valore.

Ad esempio un semplice programma che utilizzi la funzione Assoluto potrebbe essere scritto così:

program Esempio;
var n: real;

function Assoluto (x:real):real;
begin
    if x<0 then
     Assoluto := -x
    else
     Assoluto := x;
end;

begin
    write('Calcola il valore assoluto del numero ');
    readln(n);

    writeln('Il valore assoluto di ' , n:10:3, ' vale ', Assoluto(n):10:3 );
end.

Ricorsività

È possibile anche prevedere che una funzione richiami se stessa: in questo caso si parla di ricorsività.

Un esempio tipico di funzione ricorsiva è quella di fattoriale. Il fattoriale di un numero $n\in \mathbb {N}$ (si indica con $n!$) è uguale al prodotto di $n\cdot (n-1)\cdot (n-2)\cdot (n-3)...\cdot 1$ Eccone l'implementazione in Pascal:

function fattoriale (n: integer): longint;
begin
    if (n = 0) or (n = 1) then
        fattoriale := 1;
    else
        fattoriale := n * fattoriale(n-1);
end;

Analizziamo il caso di $n=3$:

• viene restituito il valore $3\cdot 2!$
• a sua volta $2!$, questo restituisce $2\cdot 1!$
• il risultato di $1!$ è 1, quindi finisce la ricorsività
• a questo punto, avremmo che il risultato sarà $3\cdot 2\cdot 1$, che è quello che volevamo ottenere

Esercizi

• Scrivere una funzione ipotenusa che, presi come valori i cateti di un triangolo rettangolo, restituisca il valore della sua ipotenusa, applicando il teorema di Pitagora

Soluzione proposta

function ipotenusa (c1:real, c2:real):real;
var ip : real;
begin
if (c1 <= 0) or (c2 <= 0) then
    writeln('dati non validi');
else
   begin
   ip := sqrt(c1 * c1 + c2* c2);
   ipotenusa := ip;
   end
end;

• Implementare una funzione che calcoli l'nesimo numero della successione di Fibonacci, già vista nel capitolo precedente, utilizzando però un algoritmo ricorsivo.

Soluzione proposta

function fibonacci(n:integer):longint;
begin
    case n of
    1:
        fibonacci:= 1;
    0:
        fibonacci:= 0
    else
        fibonacci := fibonacci(n-1) + fibonacci(n-2);
end;

In questo caso siamo partiti dalla definizione della serie, sapendo quindi che F₀ = 0 e F₁ = 1.

• Implementare una funzione strpos che prenda come parametri una stringa e un carattere, e restituisca la posizione della prima occorrenza del carattere nella stringa. Se il carattere non viene trovato, restituisce -1.

Soluzione proposta

function strpos(str: string, ch: char): integer;
    var i, ris : integer;
begin
    ris := -1;
    for i := 1 to length(str) do
    begin
        if (ris = -1) and (str[i] = ch) then
            ris := i;
    end;
    strpos := ris;
end;

La funzione scorre i caratteri della stringa e se a) il carattere non sia già stato trovato b) il carattere corrente è quello cercato, allora imposta come risultato la posizione corrente.

• Una volta risolto il precedente esercizio, non dovrebbe essere difficile scrivere una funzione simile, ma che parta dal fondo a cercare il carattere

Suggerimento

Basta capovolgere i termini del ciclo for e usare un downto

• Implementare una funzione substr che prenda come parametri una stringa e due interi, e restituisca una sottostringa partendo dal carattere in posizione specificata per una lunghezza specificata. Ad esempio se si passano come valori 'il linguaggio pascal', 4 e 5, restituisce 'lingu'.

Soluzione proposta

function substr(str: string; pos, lnt: integer): string;
    var max, i: integer;
        ris: string;
begin
    ris := '';
    if pos < length(str) then
    begin
        if length(str) > pos + lnt then
            max := pos + lnt - 1
        else
            max := length(str);
        for i := pos to max do
            ris := ris + str[i];
    end;
    substr := ris;
end;

La funzione è prevista per restituire come risultato una stringa vuota, nel caso non sia possibile fare altrimenti. Ad esempio se la posizione indicata come partenza è maggiore della lunghezza della stringa, viene restituita una stringa vuota. Se invece la posizione inserita è corretta, si procede con la funzione vera e propria.

Innanzitutto si determina la posizione del carattere finale della sottostringa (sappiamo l'inizio e la lunghezza, infatti). Decidiamo che, se con i parametri indicati, la stringa dovesse "sforare", allora verrebbe restituita la stringa fino alla fine. Dopo questa valutazione, tramite il ciclo aggiungiamo man mano alla variabile ris un carattere, fino a comporre la sottostringa finale, quella desiderata.