Sottoprogrammi in C

(1)

Elementi di Informatica 1 Prof. G. A. Di Lucca - Univ. del Sannio

Sottoprogrammi in C

• Un sottoprogramma in C viene definito nel seguente modo:

Esempio:

float Calcola ([<lista parametri formali>]) { <parte dichiarativa>

[return <espressione>;]

}

Un sottoprogramma può avere o meno una lista di argomenti (parametri)

<tipo> <nome_sottoprogramma >([<lista parametri formali>]) { sezione dichiarativa

corpo del sottoprogramma [return <espressione>;]

}

• Ogni funzione presenta un valore di ritorno che può essere di un qualsiasi tipo predefinito dal linguaggio o definito

dall’utente.

• Se nella dichiarazione viene omesso il tipo ritornato, esso viene considerato automaticamente un intero.

Funzioni in C

Procedure in C

• In C non esistono le procedure

• Essa è definita come una funzione con il tipo predefinito void

come valore di ritorno; ovvero non è ritornato alcun valore

associato al nome di quella funzione (ma solo ai parametri

passati per riferimento).

(2)

Controllo dell’esecuzione

• All’atto della chiamata di una funzione, il controllo

dell’esecuzione viene passato alla prima istruzione del corpo della funzione stessa.

• Esistono due modi per restituire il controllo al programma chiamante:

– termine dell’esecuzione della funzione (quando si incontra la “}” finale)

– attraverso l’istruzione: return [<espressione>];

• E’ opportuno controllare sempre che la chiamata di una funzione ed il suo valore di ritorno siano consistenti.

Lista dei parametri formali

• La lista dei parametri è usata per scambiare dati tra una funzione chiamante e quella chiamata. La lista può essere anche vuota.

• I parametri devono essere specificati tra parentesi e separati da virgole, dopo il nome della funzione.

• Per ciascun parametro deve essere dichiarato il suo tipo.

• Esempio:

float Calcola (int x, float y , char z) {

[return <espressione>;]

}

(3)

Parametri di una funzione

• Il metodo di passaggio dei parametri, per default, è per valore (la funzione chiamata opererà su una copia locale dei parametri attuali passati e non ne modifica il loro valore nel chiamante)

• è possibile passare i parametri per riferimento, utilizzando variabili di tipo puntatore

• E’ responsabilità del programmatore controllare che il numero ed il tipo degli argomenti passati ad una funzione corrisponda con quanto specificato nella dichiarazione della funzione stessa.

Notazione per lo scambio di parametri per riferimento

• Il meccanismo di scambio dei parametri per riferimento (per indirizzo) avviene tramite l’uso di variabili di tipo puntatore;

in tal caso la funzione chiamata sarà in grado di modificare direttamente il valore del parametro effettivo che riceve.

• Notazione nella dichiarazione di una funzione C di un argomento passato per riferimento:

<tipo> <nome_funzione> (

*

<nome_parametro>)

Es:

**void proc1(int *A, int B)**

passato per riferimento passato per valore

(4)

• Anche i parametri effettivi nella chiamata alla funzione avranno una forma diversa se passati per valore o riferimento

• Passaggio per indirizzo:

<nome_funzione_chiamata> (&<nome_parametro>) Es.:

square(&numero); //chiamata della funzione square con parametro // effettivo numero passato per riferimento riferendosi all’esempio precedente:

int x, y;

proc1(&y, x); //chiamata della funzione proc1 con parametro effettivo // y passato per riferimento e x per valore

Notazione per scambio di parametri per riferimento

[<direttive di inclusione>]

[<dichiarazioni sottoprogrammi>]

main ( ) {

<corpo del programma>

}

Struttura di un programma con sottoprogrammi in linguaggio C

#include <stdio.h>

float Area_Tr (int W, int Y) { float Area_triangolo;

Area_triangolo = (W*Y)/2;

return Area_triangolo;

} main ( )

{ float base, altezza;

printf (“Immetti valore base\n”);

scanf (“%f”, &base);

printf (“Immetti valore altezza\n”);

scanf (“%f”, &altezza);

if ((base>0)&&(altezza>0))

printf (“Area Triangolo = %f \n”, Area_Tr(base,altezza));

else printf (“Errore: valore base e/o altezza non maggiori di zero !! \n”);

}

Le dichiarazioni dei

sottoprogrammi vanno fatte prima del main

(5)

Esempio

#include <stdio.h>

// funzione che calcola il cubo di una variabile int cube(int x)

{

int a=x*x*x;

return a; // il valore di a è associato al nome ‘cube’

// della funzione e ‘ritornato’ al main

}

main () {

int I;

printf("Immetti numero per calcolarne il cubo ”);

scanf(“%d”, &I);

printf("Cubo = %d \n”, cube(I));

}

Esempio

// procedure che calcola il cubo di una variabile // il valore del cubo calcolato è associato al // parametro formale a passato per riferimento

void cube(int x, int *a) {

*a = x*x*x;

}

main ()

{ int I, I_cubo;

printf("Immetti numero per calcolarne il cubo\n ");

scanf("%d", &I);

cube (I, &I_cubo);

printf("Cubo di I= %d \n", I_cubo);

}

(6)

Conseguenze di errato meccanismo di scambio parametri

#include <stdio.h>

void swap(int x, int y) { int temp;

temp = x;

x = y;

y = temp;

} main() { int a = 3;

int b = 5;

swap(a,b);

printf(“a= %d b= %d\n”,a,b);

}

… un programma che attiva un sottoprogramma per effettuare lo scambio (swap) dei valori di due variabili

 Essendo, nel main, a = 3 e b = 5 il risultato atteso è: a = 5 e b = 3

 Qual’è l’output effettivo del programma ?

a=3 b=5 ovvero nessuno scambio

 Motivo: la funzione swap agisce su una copia delle variabili a e b perchè i parametri x e y sono passati per valore (!?!)

 la funzione deve invece agire sulle variabili stesse e quindi occorre passare gli indirizzi delle variabili, ovvero scambio per riferimento.

Esempio con il corretto scambio per riferimento

#include <stdio.h>

void swap(int *x, int *y) { int temp;

temp = *x;

*x = *y;

*y = temp;

} main()

{ int a = 3;

int b = 5;

swap(&a, &b);

printf(“a= %d b= %d\n”,a,b);

}

Quale sarà l’output del programma ? a=5 b=3

… scambio effettivamente effettuato !!

Ora x e y sono parametri formali passati per riferimento

(7)

Prototipo di una funzione

Il prototipo di una funzione rappresenta una dichiarazione di funzione (indicandone la sola intestazione) che precede la sua completa definizione.

Es. : int function(int x, char c);

int function(int,char); // indicati solo i tipi dei // parametri formali

L’uso dei prototipi è obbligatorio quando la definzione completa di una funzione avviene successivamente al suo utilizzo.

Lo scopo dei prototipi delle funzioni è quello di permettere al compilatore di compiere il controllo sui nomi della funzione e dei tipi degli argomenti che vengono passati ad una funzione.

Esempio uso prototipo

int cube(int x); //PROTOTIPO della funzione

main () {int I;

printf(" Immetti numero per calcolarne il cubo ”);

scanf(“%d”, &I);

}

// definizione della funzione int cube(int x)

{ int a=x*x*x;

return a;

}

(8)

Prototipi di funzione

• L’inserimento dei prototipi prima della definizione di una funzione, permette al compilatore, quando incontra la dichiarazione del prototipo di conoscere e controllare il numero ed i tipi degli argomenti.

• La dichiarazione e la successiva definizione di una funzione devono essere consistenti sia nel numero che nel tipo dei parametri.

• Attenzione: se prototipo e definizione di funzione si trovano nello stesso file sorgente eventuali non corrispondenze nei tipi degli argomenti saranno rilevati dal compilatore, in caso contrario al più ci sarà un warning.

Sottoprogrammi in file separati

• I sottoprogrammi possono essere inseriti in file sorgenti

separati/differenti da quello con il main( ); i file dei sorgenti dei sottoprogrammo possono essere compilati separatamente

• nel main, o nei sottoprogrammi che ne chiamano altri memorizzati in file differenti, dovrà essere indicata una direttiva di inclusione (#include) che indica il file sorgente da includere contenente il/i sottoprogramma/i chiamato/i.

(9)

Sottoprogrammi in file separati

#include <C:\cube.h> /*include il file cube.h, registrato sul

disco rigido C: contenente la funzione

cube*/

main () {

int I;

printf("Immetti numero per calcolarne il cubo ”);

scanf(“%d”, &I);

}

int cube(int x) {

int a=x*x*x;

return a;

}

La funzione cube è memorizzata nel file sorgente cube.h Attenzione: i file inclusi vanno memorizzati nella libreria di default dei file di inclusione altrimenti va indicato per intero il path di memorizzazione

per DevC++ la libreria di inclusione è la cartella include