...

Funzioni2 - B. Focaccia

by user

on
Category: Documents
3

views

Report

Comments

Transcript

Funzioni2 - B. Focaccia
In C tutti sottoprogrammi sono FUNZIONI (non esistono procedure) e
possono restituire un valore o nessun valore (void); se non dichiarato, per
default restituiscono un valore int.
Anche il main è una funzione, la prima che viene eseguita; il programma
chiamante è il SO.
Una funzione può restituire un valore (int, float….) o nessun valore (void)
ad un’altra funzione; può ricevere un valore (int, float, ….) o nessun valore
(void) da un’altra funzione:
tipo_restituito NOMEFUNZIONE (eventuali parametri di ingresso)
prima della funzione si definisce il tipo di dato restituito in OUT per
un’altra funzione; tra parentesi si elencano i parametri di ingresso
provenienti da un’altra funzione.
PERCHE’ USARE PROCEDURE E FUNZIONI?
1. RISPARMIO DI CODICE: consentono di evitare di dover riscrivere
lunghe sequenze di istruzioni identiche in più punti dello stesso
programma; quindi consentono una riduzione di TEMPO per la scrittura
e la verifica dei programmi e una riduzione di SPAZIO occupato dai
programmi
2. ASTRAZIONE PROCEDURALE: consentono di analizzare i problemi con
la scomposizione TOP- DOWN; dal punto di vista del programmatore,
nel momento in cui richiama una procedura, egli si astre dai dettagli
insisti nel corpo della procedura: egli chiede semplicemente che in quel
punto venga risolto il sottoproblema, senza preoccuparsi di come verrà
risolto; quindi la procedura/funzione è vista come una BLACK BOX
(scatola nera)
3. EFFICIENTE DIVISIONE DEL LAVORO: quando ad un progetto
partecipano più persone, ogni procedura viene sviluppata in modo
autonomo; per questo motivo è bene usare solo variabili locali e passare
i parametri con l’interfaccia della procedura/funzione.
4. RIUSABILITA’ DEL CODICE: la stessa procedura/funzione può essere
usata in punti diversi del codice o in altri codici solo se è stata ben
costruita, se è il più generale possibile e se comunica solo attraverso al
sua interfaccia e utilizza solo variabili locali.
SINTASSI GENERALE DI UNA PROCEDURA/FUNZIONE IN C
OUT
Tipo_di_ritorno NOME(tipo_parametro, tipo_parametro….)
IN (parametri
{
formali
o
dichiarazione variabili locali (sono visibili solo all’interno e non sono previsti nell’interfaccia)
interfaccia)
istruzioni:…..
return NOMEVARIABILE; (eventuale variabile in OUT, da passare ad altre funzioni, dello stesso
tipo di tipo_di_ritorno)
}
Int PIPPO(void);
è il prototipo di una funzione che non riceve nulla ma che restituisce un
intero.
Esempio: funzione che eleva al cubo un numero intero
float ELEVO (int NUMERO)
{
int I;
//variabili locali
float RISULTATO;
RISULTATO=1;
//corpo della funzione
for (I=1; I<=3; I++)
RISULTATO *= NUMERO; //equivale a RISULTATO= RISULTATO*NUMERO
return RISULTATO;
}
Il CONCETTO DI RESTITUZIONE (O RITORNO) del valore di una
funzione deve essere visto dal punto di vista della funzione: è una
restituzione di valore per un’altra funzione. Se una funzione contiene una
istruzione per comunicare un risultato in output (video), non passa nulla ad
un’altra funzione: il prototipo sarà void COMUNICA(float);
la definizione della funzione è:
void COMUNICA (float RIS)
{
printf (“risultato= %4.2F”, RIS);
}
Questa funzione non restituisce nulla, quindi l’istruzione RETURN viene
omessa; se una funzione restituisce un valore, deve essere presente
l’istruzione return (come nell’esempio precedente: la funzione ELEVO)
il CONCETTO DI INGRESSO del/dei parametri di una funzione deve
essere considerato dal punto di vista della funzione: un dato è in entrata
per la funzione, se proviene da un’altra funzione (nell’esempio precedente
il parametro RIS proviene da una funzione precedente); non confondetevi
con le funzioni per l’acquisizione dei dati: ad esempio una funzione che
permette di acquisire da tastiera un numero intero non riceve nulla
dall’esterno, cioè da un'altra funzione, ma deve restituire un intero alle
funzioni che la seguono, per le elaborazioni; il prototipo sarà:
la sua definizione è:
int INSERISCI (void)
{
int NUMERO;
//variabile locale, non ancora dichiarata
printf (“inserisci un numero intero\n”);
scanf (“%d”, &NUMERO);
return NUMERO;
//valore da restituire per le funzioni successive
}
//*programma che riceve un numero tra 1 e 50 e restituisce la somma dei *//
//* numeri da 1 al numero inserito *//
#include <stdlib.h>
#include <stdio.h>
int INSERISCI(void);
int SOMMA(int);
int COMUNICA(int);
main()
{
int NUMERO;
int RISULTATO;
//var. locali del main
NUMERO = INSERISCI();
RISULTATO= SOMMA(NUMERO);
COMUNICA(RISULTATO);
system("PAUSE");
}
int INSERISCI(void)
{
int N;
//var. locale
do
{
printf ("inserire un numero tra 1 e 50\n");
scanf ("%d", &N);
if ((N<1)||(N>50))
printf ("numero non corretto; riprova\n");
}
while ((N<1)||(N>50));
return N;
}
int SOMMA(int NUM)
{
int I;
//var. locali
int RIS;
RIS=0;
for (I=1; I<=NUM; I++)
RIS += I;
return RIS;
}
int COMUNICA(int RISULT)
{
printf ("risultato della somma da 1 al numero = %4.0d\n", RISULT);
}
#include <stdio.h>
#include <stdlib.h>
#define SIZE 5
void modificaArray( int [], int );
void modificaElemento( int );
int main()
{
int a[ SIZE ] = { 0, 1, 2, 3, 4 }, i;
printf( "Vettore Originale" );
for ( i = 0; i <= SIZE - 1; i++ )
printf( "%3d", a[ i ] );
printf( "\n" );
//* Modifichiamo il vettore **//
modificaArray( a, SIZE );
printf( "Vettore Modificato:\n" );
for ( i = 0; i <= SIZE - 1; i++ )
printf( "%3d", a[ i ] );
//* Modifichiamo l'elemento **//
printf( "\n\n\n Valore prima della modifica %d\n", a[ 3 ] );
modificaElemento( a[ 3 ] );
printf( "Il Valore modificato a[ 3 ] = %d\n", a[ 3 ] );
system("pause");
}
void modificaArray( int b[], int size )
{
int j;
for ( j = 0; j <= size - 1; j++ )
b[ j ] *= 2;
}
void modificaElemento( int e )
{
printf( "Valore modificato= %d\n", e *= 2 );
}
// // FUNZIONE CHE CALCOLA LA PASQUA //
#include <stdio.h>
#include <stdlib.h>
void pasqua(short aa, short *mm, short *gg)
{
short gm[] = {22, 22, 23, 23, 24, 24};
short da[] = {2, 2, 3, 4, 5, 5};
short a, b, c, d, e, i;
a = aa % 19;
b = aa % 4; c = aa % 7;
i = (int) (aa / 100) - 15;
d = (19 * a + gm[i]) % 30;
e = (2 * b + 4 * c + 6 * d + da[i]) % 7;
*gg = 22 + d + e;
*mm = 3;
if (*gg > 31)
{
*mm = 4; *gg -= 31;
}
}
main()
{
{ short giorno, mese, anno = 2009;
pasqua(anno, &mese, &giorno);
printf("Pasqua %d cade il giorno %d del mese %d\n", anno, giorno, mese); }
system("PAUSE");
}
Fly UP