Adesso che abbiamo imparato a usare le funzioni, sia quelle di library sia quelle scaricate da internet, proviamo a classificare i diversi tipi di funzioni esistenti. La nostra classificazione, come vedremo fra poco, si basa sugli argomenti (cioè sui valori di ingresso che devono essere passati alla funzione) e sul tipo del valore di ritorno (cioè sul risultato del calcolo effettuato dalla funzione).
Per comodità useremo come esempi funzioni della library standard del C++, ma tutto ciò che segue si applica in generale a qualsiasi funzione, sia essao di library oppure esterna.
Il tipo di funzione più semplice, per verità non molto usato, è quello che non ha argomenti né valore di ritorno. Si tratta cioè di funzioni che non hanno bisogno di nessun valore di ingresso e che non restituiscono nessun risultato al termine dell'elaborazione.
Un esempio di questo tipo di funzioni, tratto dalla library standard del C++, è la funzione abort:
Nome della funzione: abort
Prototipo: void abort(void);
Descrizione: interrompe il programma in esecuzione
Esempio di chiamata: abort();
Vale la pena, prima di continuare, di vedere un semplice esempio di programma che usa la funzione:
#include <cstdlib>
#include <iostream>
void abort(void);
using namespace std;
int main(int argc, char *argv[])
{
double num1, num2;
cout<<"Fornisci il dividendo: ";
cin>>num1;
cout<<"Fornisci il divisore: ";
cin>>num2;
if (num2==0)
abort();
cout<<"Il risultato della divisione e': "<<num1/num2<<"\n";
system("PAUSE");
return EXIT_SUCCESS;
}
Il programma usa la funzione abort per interrompere (abortire) l'esecuzione nel caso in cui il divisore sia uguale a zero. Effettivamente non è un programma particolarmente intelligente e ci sono molti modi migliori per terminare un programma in caso di errore. Comunque non ci si concentri tanto sull'esempio specifico, quanto sull'uso della funzione. Come si può notare, le funzioni senza argomenti e senza valore di ritorno si chiamano semplicemente così:
abort();
La coppia di parentesi graffe aperta e chiusa è essenziale, ma in questo caso esse non contengono nulla. Per quanto riguarda il prototipo:
void abort(void);
si notino le due parole chiave void, prima della funzione e fra le parentesi, che indicano appunto l'assenza (vuoto) di argomenti e di valore di ritorno. In questo caso, come si può osservare, non vale la regola generale che dice che il prototipo è uguale all'intestazione della funzione.
Un caso un po' più interessante è rappresentato dalle funzioni che non ricevono argomenti, ma che ritornano comunque un risultato. Un esempio di questo genere di funzioni è costituito dalla rand, per la generazione di numeri pseudocasuali (random):
Nome della funzione: rand
Prototipo: int rand(void);
Descrizione: genera un numero pseudocasuale compreso fra 0 e 32767
Esempio di chiamata: num = rand();
Vediamo subito un esempio di utilizzo della funzione rand:
#include <cstdlib>
#include <iostream>
int rand(void);
using namespace std;
int main(int argc, char *argv[])
{
int n,caso;
cout<<"Quanti numeri casuali vuoi generare? ";
cin>>n;
while (n>0)
{
caso = rand();
cout<<caso<<"\n";
n--;
}
system("PAUSE");
return EXIT_SUCCESS;
}
Si osservino in particolare la chiamata e il prototipo (che contiene la parola chiave void fra parentesi, per indicare l'assenza di argomenti nella chiamata alla funzione).
Consideriamo ora un esempio speculare al precedente: quello di una funzione che non torna nessun valore, ma che ha un valore di ingresso (argomento): la funzione srand.
Nome della funzione: srand
Prototipo: void srand ( unsigned int seed );
Descrizione: inizializza la sequenza di numeri pseudocasuali
Esempio di chiamata: srand(num);
Per comprendere questa funzione bisogna sapere che i numeri generati dalla rand non sono veri numeri casuali, ma pseudocasuali. Infatti essi non sono il risultato di una qualche operazione intrinsecamente casuale (come per esempio lanciare un dado), ma provengono invece da un calcolo matematico che, in quanto tale, non è casuale essendo ripetibile. Prova ne è che se viene eseguito più volte il programma dell'esempio precedente (quello che usa la rand), la sequenza dei numeri pseudocasuali generati è sempre la stessa!
Per ovviare a questo problema si usa appunto la srand che dev'essere chiamata una sola volta prima della rand, allo scopo di inizializzare la sequenza pseudocasuale. La sequenza viene inizializzata partendo da un seme (seed) intero, il quale (mi rendo conto che è un po' complicato) non è il primo numero della sequenza, come si potrebbe pensare, ma semplicemente un valore a partire dal quale l'algoritmo inizia a generare i numeri casuali.
In pratica si usa il trucco di chiamare la srand passandole come seme il numero di secondi dell'orologio del computer. Siccome tale valore è abbastanza casuale, anche la sequenza corrispondente lo sarà. Questo è un esempio di uso della funzione:
Il caso di gran lunga più frequente è quello di funzioni che hanno sia argomenti che valore di ritorno. Abbiamo già incontrato esempi di questo tipo di funzioni. Appartengono a questa categoria ad esempio sia le funzioni sin e pow (della library matematica standard) che la funzione isprime.
Vediamo in particolare la sin:
Nome della funzione: sin
Prototipo: double sin( double x);
Descrizione: calcola la funzione seno
Esempio di chiamata: y = sin(x);
e la funzione pow:
Nome della funzione: pow
Prototipo: double pow(double base, double exponent);
Descrizione: calcola l'elevamento a potenza
Esempio di chiamata: y = pow(base,esponente);
E' interessante notare che, mentre il valore di ritorno di una funzione è sempre uno (o nessuno, nelle funzioni void), il numero di argomenti può in generale essere qualsiasi. In altre parole, una funzione può ricevere un numero di valori di ingresso variabile (da una funzione a un'altra), ma il risultato del calcolo è sempre uno solo.
Gli argomenti di una funzione sono obbligatori nella chiamata di una funzione (tranne che per le funzioni con numero di argomenti variabile, di cui non ci occuperemo). Il valore di ritorno invece può essere trascurato, cioè è possibile usare una funzione con valore di ritorno come se si trattasse di una funzione void.
Questo uso è frequente con alcune funzioni di library, quando esse tornano un codice di errore (che non si vuole controllare) oppure un altro dato che può essere trascurato.
Come esempio consideriamo la funzione putchar, che serve per visualizzare un carattere sullo schermo:
Nome della funzione: putchar
Prototipo: int putchar ( int character );
Descrizione: visualizza character sullo schermo.
La funzione, se non ci sono errori, ritorna lo stesso carattere che è stato visualizzato. In caso di errore, torna una costante speciale denominata EOF. Vediamo un esempio di uso di questa funzione per visualizzare il carattere 'W':
#include <cstdlib>
#include <iostream>
using namespace std;
int main(int argc, char *argv[])
{
if (putchar('W')==EOF)
cout<<"Errore: visualizzazione fallita!\n";
system("PAUSE");
return EXIT_SUCCESS;
}
Nell'esempio qui sopra la putchar è usata verificando l'eventuale presenza di una segnalazione di errore. Tuttavia nella maggior parte dei casi questa verifica non è necessaria e la funzione viene usata più semplicemente così (come se non avesse valore di ritorno):
#include <cstdlib>
#include <iostream>
using namespace std;
int main(int argc, char *argv[])
{
putchar('W');
system("PAUSE");
return EXIT_SUCCESS;
}
Sito realizzato in base al template offerto da
http://www.graphixmania.it
