PROCEDURE E FUNZIONI (SOTTOPROGRAMMI)

Ogni linguaggio di programmazione offre dei costrutti per decomporre un programma in sottoparti, dette genericamente sottoprogrammi.
Esistono due tipologie di sottoprogrammi:

PROCEDURA: una sottoparte di programma che corrisponde ad uno statement (istruzione);
FUNZIONE: una sottoparte di programma che corrisponde ad una espressione di un certo tipo.

Ogni sottoprogramma è caratterizzato da:

NOME: per identificare e usare, anche più volte, tale sottoparte;
PARAMETRI (anche nessuno): i sottoprogrammi possono essere parametrizzati su valori, variabili, file, altri sottoprogrammi, ...;
BODY (CORPO): il testo che definisce la sottoparte vera e propria.

La struttura di un programma diventa ora

SUBPROGRAM DECLARATIONS
MAIN

una dichiarazione di sottoprogramma ha una delle seguenti forme:
- ```
procedureIDENTIFIER(PARAMETERS) STATEMENT
```
  IDENTIFIER e STATEMENT sono rispettivamente il nome ed il body della procedura
- ```
function IDENTIFIER(PARAMETERS):TYPE STATEMENT'
```
  IDENTIFIER è il nome della funzione,
  TYPE e STATEMENT' sono rispettivamente il tipo dei valori dell'espressione corrispondente al sottoprogramma e lo statement che permette di calcolarne il valore.
  Ogni linguaggio di programmazione ha delle istruzioni speciali per determinare alla fine del calcolo quale è il valore di tale espressione (es. in Pascal si assegna tale valore al nome della funzione).
MAIN è il programma vero e proprio (cioè la parte principale). I sottoprogrammi dichiarati sopra vengono usati al suo interno attraverso il meccanismo della chiamata.
Una chiamata di procedura può apparire in ogni punto dove potrebbe apparire uno statement, mentre una chiamata di funzione può apparire in ogni punto dove potrebbe apparire un'espressione del tipo corrispondente.
Una chiamata di un sottoprogramma è è costituita dal nome del sottoprogramma e dagli elementi che istanziano i parametri (i cosidetti parametri attuali).

PARAMETRI

I parametri di un sottoprogramma vengono elencati nella dichiarazione del sottoprogramma stesso (i cosidetti parametri formali) e possono essere di diversa natura.
Le tipologie dei parametri più comuni sono:

VALORI (di un qualche tipo di dato del linguaggio)

la dichiarazione del parametro (parametro formale) ha la forma generica

value IDENTIFIER : TYPE

mentre il corrispondente parametro attuale è semplicemente un'espressione EXP di tipo TYPE.

Ogni linguaggio può poi precisare come avviene il passaggio del parametro più dettagliatamente; per esempio

per nome: ogni occorrenza di IDENTIFIER nel corpo del sottoprogramma viene rimpiazzata dal testo di EXP
per copia: IDENTIFIER è una variabile dichiarata implicitamente all'inizio del corpo del sottoprogramma che viene inizializzata con il valore di EXP al momento della chiamata; in certi linguaggi non è più possibile assegnare un nuovo valore a tale variabile.

VARIABILI (di un qualche tipo del linguaggio)

la dichiarazione del parametro (parametro formale) ha la forma generica

variable IDENTIFIER : TYPE

mentre il corrispondente parametro attuale è semplicemente una variabile VAR di tipo TYPE;
più precisamente o una variabile di un tipo semplice o una componente di una variabile di un tipo strutturato, cioè ogni cosa che può essere trovata a sinistra di un'assegnazione.
Seguendo la metafora variabile=scatola, in questo caso il parametro formale è un nome generico di scatola, mentre quello attuale è il nome di una scatola particolare, cioè il sottoprogramma è parametrizzato su una scatola.

SOTTOPROGRAMMI

Ogni linguaggio di programmazione precisa se e quali forme di sottoprogrammi possono essere usate per parametrizzare altri sottoprogrammi

FILE

Ogni linguaggio di programmazione permette di parametrizzare i sottoprogrammi con dei file; in questi casi il parametro formale è un nome generico di un file di un certo tipo, mentre quello attuale deve essere il nome di un file dello stesso tipo esistente.

Chiaramente all'interno dei sottoprogrammi possiamo utilizzare tutti i costrutti del linguaggio, quindi per esempio chiamare altri sottoprogrammi ed anche dichiarare sottoprogrammi che saranno utilizzati solamente al loro interno.

ESERCIZIO

Definire una forma di sottoprogrammi per il calcolatore antropomorfo, precisando quali siano i parametri ed il modo in cui sono passati.

USO DEI SOTTOPROGRAMMI

I sottoprogrammi sono i costrutti più semplici ed usati per strutturare ed organizzare i programmi, allo scopo di

migliorare la loro leggibilità: il programma è suddiviso in sottoparti ognuna indicata da un nome significativo (un po' come i capitoli ed i sottocapitoli in un libro).
questa scomposizione è importante per poter permettere modificare, correggere, ed aggiornare i programmi.
favorire la loro scrittura corretta,: poichè è più facile produrre correttamente piccoli sottopezzi di programmi, ed inoltre la scomposizione in pezzi permette di controllare più facilmente la struttura complessiva del programma
permettere di riutilizzare parti già sviluppate: se in un programma occorre fare più volte le stesse cose utilizzando i sottoprogrammi il codice relativo si scrive una volta sola (nella dichiarazione) e poi si riusa (nelle chiamate); inoltre è possibile riusare sottoprogrammi scritti da altri o da noi stessi in altre occassioni
favorire l'uso di metodi per il loro sviluppo: (es. sviluppo top-down e bottom up).

I SOTTOPROGRAMMI IN C

Il linguaggio C ha la possibilità di dichiarare ed usare sottoprogrammi sia di tipo procedura che di tipo funzione, anche se a livello di terminologia essi sono chiamati sempre funzioni, e le procedure sono semplicemente delle funzioni che ritornano un valore di un tipo speciale, void, che ha un unico valore.

Inoltre il C ha solo parametri valore, e pertanto gli altri tipi devono essere ottenuti in modo indiretto utilizzando i puntatori.

La forma di una dichiarazione di funzione in C è:

TYPE IDENTIFIER ( PARAMETERS )
BLOCK

TYPE: il tipo dei valori ritornati dalla funzione, non può essere un array. Si usa void per le procedure (che sono infatti delle funzioni che non ritornano niente).
IDENTIFIER: il nome della funzione
PARAMETERS: le dichiarazoni dei parametri formali. Si usa void quando la funzione non ha alcun parametro.
I parametri, che sono tutti di tipo valore e sono passati per copia, si dichiarano semplicemente premettendo il tipo al nome del parametro e si separano con virgole.
BLOCK: è il corpo della funzione (un blocco), e quindi può contenere dichiarazioni di variabili locali, cioè utilizzate solo all'interno della funzione.
Se il sottoprogramma è una vera funzione, il C fornisce lo statement
return(EXPR);
per terminare il calcolo e ritornare il valore della funzione, che è giusto il valore di EXPR.

La forma di un programma C con dichiarazioni di funzioni è semplicemente una lista di dichiarazioni di funzioni e un main, come prima.
Notare che il main è semplicemente una procedura di nome main senza parametri, scritta usando la sintassi di una versione più vecchia del C.

ESEMPI

funzione che calcola il fattoriale

#include <stdio.h>

int Fatt(int n)
{  
    if(n < 0)
       printf("Il numero non puo\' essere negativo\n");
    else if(n == 0)
       return(0);
    else{
       int f;
       
       f = 1;
       while(n >= 1){
           f = f * n;
           n = n-1;
       };
       return(f);
   };
}

main(){
    int n, f; 

    printf("dare il numero\n");
    scanf("%d",&n);
    f = Fatt(n);
    printf("Il fattoriale di %d e\' %d \n",n, f);
    
}

procedura per stampare una matrice

#include <stdio.h>
#define DIM 100

void Stampa_Mat(int m[DIM][DIM])
/*stampa m sullo standard output riga per riga*/
{  
    int i,j;
    
    for(i=0; i < DIM; i=i+1){
        for(j=0; j  < DIM; j=j+1)
            printf("%7d ",m[i][j]);
        printf("\n");
    }
}

main(){
    int a[DIM][DIM], i, j, s; 

    printf("dare la matrice su una unica riga\n");
    for(i=0; i  < DIM; i=i+1)
        for(j=0; j < DIM; j=j+1){
            scanf("%d",&s); a[i][j]=s;};

    Stampa_Mat(a);    
}}