Pascal - Procedure

Procedures sono sottoprogrammi che, invece di restituire un unico valore, permettono di ottenere un gruppo di risultati.

Definizione di una procedura

In Pascal, una procedura viene definita utilizzando il procedureparola chiave. La forma generale della definizione di una procedura è la seguente:

procedure name(argument(s): type1, argument(s): type 2, ... );
   < local declarations >
begin
   < procedure body >
end;

Una procedura definition in Pascal è costituito da a header, Locale declarations e a bodydella procedura. L'intestazione della procedura è costituita dalla parola chiaveproceduree un nome dato alla procedura. Ecco tutte le parti di una procedura:

• Arguments- Gli argomenti stabiliscono il collegamento tra il programma chiamante e gli identificatori di procedura e sono anche chiamati parametri formali. Le regole per gli argomenti nelle procedure sono le stesse di quelle per le funzioni.

• Local declarations - Le dichiarazioni locali si riferiscono alle dichiarazioni per etichette, costanti, variabili, funzioni e procedure, che sono applicabili solo al corpo della procedura.

• Procedure Body- Il corpo della procedura contiene una raccolta di istruzioni che definiscono cosa fa la procedura. Dovrebbe essere sempre racchiuso tra le parole riservate inizio e fine. È la parte di una procedura in cui vengono eseguiti tutti i calcoli.

Di seguito è riportato il codice sorgente di una procedura chiamata findMin () . Questa procedura accetta 4 parametri x, y, ze m e memorizza il minimo tra le prime tre variabili nella variabile denominata m. La variabile m viene passatareference (discuteremo il passaggio di argomenti per riferimento un po 'più tardi) -

procedure findMin(x, y, z: integer; var m: integer); 
(* Finds the minimum of the 3 values *)

begin
   if x < y then
      m := x
   else
      m := y;
   
   if z <m then
      m := z;
end; { end of procedure findMin }

Dichiarazioni di procedura

Una procedura declarationindica al compilatore il nome di una procedura e come chiamare la procedura. Il corpo effettivo della procedura può essere definito separatamente.

Una dichiarazione di procedura ha la seguente sintassi:

procedure name(argument(s): type1, argument(s): type 2, ... );

Si prega di notare che il file name of the procedure is not associated with any type. Per la procedura sopra definita findMin () , di seguito è riportata la dichiarazione -

procedure findMin(x, y, z: integer; var m: integer);

Chiamare una procedura

Durante la creazione di una procedura, si fornisce una definizione di ciò che la procedura deve fare. Per utilizzare la procedura, dovrai chiamare quella procedura per eseguire l'attività definita. Quando un programma chiama una procedura, il controllo del programma viene trasferito alla procedura chiamata. Una procedura chiamata esegue l'attività definita e quando viene raggiunta la sua ultima istruzione end, restituisce il controllo al programma chiamante.

Per chiamare una procedura, è sufficiente passare i parametri richiesti insieme al nome della procedura come mostrato di seguito -

program exProcedure;
var
   a, b, c,  min: integer;
procedure findMin(x, y, z: integer; var m: integer); 
(* Finds the minimum of the 3 values *)

begin
   if x < y then
      m:= x
   else
      m:= y;
   
   if z < m then
      m:= z;
end; { end of procedure findMin }  

begin
   writeln(' Enter three numbers: ');
   readln( a, b, c);
   findMin(a, b, c, min); (* Procedure call *)
   
   writeln(' Minimum: ', min);
end.

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Enter three numbers:
89 45 67
Minimum: 45

Sottoprogrammi ricorsivi

Abbiamo visto che un programma o un sottoprogramma può chiamare un altro sottoprogramma. Quando un sottoprogramma chiama se stesso, viene indicato come una chiamata ricorsiva e il processo è noto come ricorsione.

Per illustrare il concetto, calcoliamo il fattoriale di un numero. Il fattoriale di un numero n è definito come -

n! = n*(n-1)!
   = n*(n-1)*(n-2)!
      ...
   = n*(n-1)*(n-2)*(n-3)... 1

Il seguente programma calcola il fattoriale di un dato numero chiamando se stesso ricorsivamente.

program exRecursion;
var
   num, f: integer;
function fact(x: integer): integer; (* calculates factorial of x - x! *)

begin
   if x=0 then
      fact := 1
   else
      fact := x * fact(x-1); (* recursive call *)
end; { end of function fact}

begin
   writeln(' Enter a number: ');
   readln(num);
   f := fact(num);
   
   writeln(' Factorial ', num, ' is: ' , f);
end.

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

Enter a number:
5
Factorial 5 is: 120

Di seguito è riportato un altro esempio, che genera il file Fibonacci Series per un dato numero utilizzando a recursive funzione -

program recursiveFibonacci;
var
   i: integer;
function fibonacci(n: integer): integer;

begin
   if n=1 then
      fibonacci := 0
   
   else if n=2 then
      fibonacci := 1
   
   else
      fibonacci := fibonacci(n-1) + fibonacci(n-2);
end; 

begin
   for i:= 1 to 10 do
   
   write(fibonacci (i), '  ');
end.

Quando il codice precedente viene compilato ed eseguito, produce il seguente risultato:

0 1 1 2	3 5 8 13 21 34

Argomenti di un sottoprogramma

Se un sottoprogramma (function or procedure) è quello di utilizzare argomenti, deve dichiarare variabili che accettano i valori degli argomenti. Queste variabili sono chiamateformal parameters del sottoprogramma.

I parametri formali si comportano come altre variabili locali all'interno del sottoprogramma e vengono creati all'ingresso nel sottoprogramma e distrutti all'uscita.

Durante la chiamata a un sottoprogramma, ci sono due modi in cui gli argomenti possono essere passati al sottoprogramma:

Suor n	Tipo di chiamata e descrizione
1	Chiama per valore Questo metodo copia il valore effettivo di un argomento nel parametro formale del sottoprogramma. In questo caso, le modifiche apportate al parametro all'interno del sottoprogramma non hanno effetto sull'argomento.
2	Chiama per riferimento Questo metodo copia l'indirizzo di un argomento nel parametro formale. All'interno del sottoprogramma, l'indirizzo viene utilizzato per accedere all'argomento effettivo utilizzato nella chiamata. Ciò significa che le modifiche apportate al parametro influiscono sull'argomento.

Per impostazione predefinita, Pascal utilizza call by valueper passare argomenti. In generale, ciò significa che il codice all'interno di un sottoprogramma non può modificare gli argomenti utilizzati per chiamare il sottoprogramma. Il programma di esempio che abbiamo usato nel capitolo "Pascal - Funzioni" ha chiamato la funzione denominata max () usingcall by value.

Mentre, il programma di esempio fornito qui ( exProcedure ) chiama la procedura findMin () usandocall by reference.