Un esempio: Calcolo della potenza n-esima di un numero reale Linguaggio C++ Funzioni Un esempio: Calcolo della potenza n-esima di un numero reale

Nella fase d’implementazione di un programma, come nella fase di analisi del problema, è consigliabile suddividere il codice in tante parti, ciascuna delle quali risolve un particolare aspetto del problema. Tali parti, in C++, prendono il nome di funzioni

La loro struttura è del tutto simile a quella già vista per il main: un insieme di dati e istruzioni, racchiusi tra parentesi graffe cui è associato un nome e che ritorna un valore. Al momento del runtime, il nome della funzione scritto all’interno di un segmento di programma, provoca l’esecuzione dell’insieme d’istruzioni associato

Per affrontare il tema delle funzioni si analizza, come pretesto, il problema del calcolo della potenza intera di un numero reale supponendo di coinvolgere nella sua risoluzione più gruppi di persone. Si vedrà come l’uso delle funzioni semplifichi questo compito, permettendo altresì di scrivere il programma in un formato più leggibile, compatto ed elegante

Analisi del problema Si desidera scrivere un programma che calcoli la potenza n-esima di un numero reale x: con n intero, positivo o negativo

La prima versione dell’algoritmo risolutivo è ancora molto semplice: Potenza di un numero reale { Acquisisci il valore di x e di n Calcola la potenza Comunica il risultato }

Evidenziati gli aspetti fondamentali del problema (top), si procede scomponendoli in fasi più semplici, fino ad arrivare a una forma non più divisibile (down). Se l’esempio proposto facesse realmente parte di un grande progetto, alcuni componenti del gruppo di lavoro potrebbero non conoscerne i dettagli. Ognuno di loro, o in piccoli gruppi, si occuperà di una fase cercando di sfruttare al meglio le proprie competenze specifiche

Gli algoritmi rappresentati di seguito potrebbero costituire un primo esempio di tale lavoro: Acquisisci il valore di x e di n si occupa di acquisire dalla tastiera il valore della base x e dell’esponente n e non necessita di ulteriori scomposizioni

L’algoritmo Calcola la potenza si occupa di calcolare il valore della potenza n-esima di x tenendo conto che se n è negativo la potenza è data dal reciproco della potenza (positiva) di x:

Sviluppando il blocco Calcola la potenza si ottiene: { SE (n >= 0) esponente  n ALTRIMENTI { esponente  –n Calcola la potenza positiva SE (n < 0) potenza  1 / potenza }

Come si nota, nella fase di scomposizione di questo algoritmo è stato necessario ricorrere ad un’altro algoritmo, Calcola la potenza positiva, che calcolerà il valore della potenza n-esima (positiva) di x. In linguaggio di programmazione, questa scelta “naturale” si tradurrà nella chiamata della funzione specializzata in questo compito

L’algoritmo Calcola la potenza positiva moltiplica x per sé stessa per esponente – 1 volte, ovvero eleva x a esponente: Calcola la potenza positiva { potenza  1 numeroVolte  1 FINCHÉ (numeroVolte <= esponente) { potenza  potenza · x numeroVolte  numeroVolte + 1 } Se esponente è 0 non viene effettuata nessuna moltiplicazione perché x0 vale 1

L’algoritmo Comunica il risultato ha il compito di comunicare il valore del polinomio. La comunicazione può avvenire presentando il valore sullo schermo, stampandolo, scrivendolo su un file o inviandolo a un’altra periferica d’uscita. In questo esempio si suppone di visualizzarlo sullo schermo. Non sono quindi necessarie ulteriori scomposizioni

Nella fase di trasformazione del programma in C++ questi algoritmi, tranne Acquisisci il valore di x e di n, sono stati scritti sottoforma di funzione. Sì è così ottenuto un programma il cui main ha la stessa chiarezza e semplicità di lettura dell’algoritmo di base

/* Programma per il calcolo della potenza intera di un numero reale. Versione con uso di funzioni */ #include <iostream> using namespace std; double x, potenza; // di x elevata a n int n, esponente; // esponente ed esponente assoluto int numeroVolte; // variabile di ciclo char op; // carattere di separazione tra x e n

// Funzione che calcola x elevata a esponente void CalcolaPotenzaPositiva() { potenza = 1; // Inizializza la variabile accumulatore for(numeroVolte = 1; numeroVolte <= esponente; numeroVolte++) potenza *= x; // potenza = potenza * x }

// Funzione che calcola x elevata a n void CalcolaPotenza() { // in esponente va il valore assoluto di n if (n >= 0) esponente = n; else esponente = -n; CalcolaPotenzaPositiva(); // Chiamata di funzione // se n è negativo calcola il reciproco if (n < 0) potenza = 1 / potenza; }

void ComunicaRisultato() { cout << "Il valore della potenza e': “ << potenza << endl; } // Funzione principale del programma int main() // Acquisisci il valore della x e di n cout << "Scrivi la potenza da calcolare ” "nel formato x^n: "; cin >> x >> op >> n; CalcolaPotenza(); // Chiamata di funzione ComunicaRisultato(); // Chiamata di funzione

Si osservi come la struttura delle funzioni utilizzate dal programma sia simile a quella della funzione principale main. Ognuna di esse, infatti, costituisce un vero e proprio sottoprogramma, che sarà eseguito quando richiesto

Definizione e chiamata di una funzione Ogni funzione è costituita da un’intestazione, in cui è indicato il nome, e da un corpo dove, tra parentesi graffe, sono racchiuse le istruzioni che dovranno essere eseguite quando la funzione verrà chiamata

Tale struttura prende il nome di definizione di funzione intestazione NomeFunzione() { ... } corpo Tale struttura prende il nome di definizione di funzione

Questa istruzione prende il nome di chiamata di funzione Per fare in modo che le istruzioni del corpo della funzione siano eseguite è sufficiente scriverne il nome seguito dalle parentesi tonde () e dal carattere terminatore ; : NomeFunzione(); Questa istruzione prende il nome di chiamata di funzione

Esecuzione di un programma Ogni programma è comunemente costituito da numerose funzioni, ciascuna delle quali ha lo scopo di risolvere un determinato problema. Fra queste, ne esiste una di nome main che stabilisce il punto dal quale avrà inizio l’esecuzione del programma. Al main di solito è affidato il compito di controllare la sequenza del programma

Durante l’esecuzione di una chiamata di funzione, il controllo del programma passa alla prima istruzione del corpo della funzione. Terminata l’esecuzione del sottoprogramma, il controllo è restituito alla funzione chiamante che proseguirà eseguendo l’istruzione successiva alla chiamata di funzione

void CalcolaPotenza() { ... Funzione chiamante Funzione chiamata Chiamata di funzione int main() { ... CalcolaPotenza(); } void CalcolaPotenza() { ... }

Vantaggi nell’uso delle funzioni I principali vantaggi nell’uso delle funzioni si possono sintetizzare nei seguenti tre punti: 1. il raggruppamento di un certo numero di istruzioni sotto un unico nome aumenta la leggibilità del codice sorgente e ne può ridurre sia la dimensione sia il tempo necessario per scriverlo;

2. nel caso di problemi di complessità elevata, dove è richiesta la partecipazione di più persone allo sviluppo di un progetto, l’uso delle funzioni costituisce senz’altro l’organizzazione più produttiva, perché permette un’efficiente suddivisione del lavoro; 3. le funzioni rendono concreta l’analisi dei problemi con il procedimento top-down

È anche bene ricordare che una funzione può essere richiamata dall’interno di un’altra funzione (CalcolaPotenzaPositiva() è stata chiamata da CalcolaPotenza()). Inoltre, per utilizzare una funzione non è necessario conoscerne i dettagli

Per esempio, per ottenere il valore di xn è sufficiente sapere che occorre chiamare la funzione CalcolaPotenza() inizializzando opportunamente le sue variabili di ingresso x ed n e che, dopo la chiamata, il risultato sarà disponibile nella variabile di ritorno potenza

In questo modo nulla vieta a una funzione scritta per un programma di essere impiegata per realizzarne un altro: si possono così organizzare apposite librerie (sottoforma di file) dalle quali poi richiamare le funzioni che occorrono, senza la necessità di doverle riscrivere ogni volta

Questo espediente permette altresì di modificare il corpo di una funzione (per esempio per correggerla, renderla più efficiente o mutarne addirittura il comportamento) senza dover intervenire sul programma che la utilizza