Funzioni In C le funzioni sono caratterizzate da

Funzioni • In C++ le funzioni sono caratterizzate da un nome, dal tipo della variabile ritornata e da una lista di parametri (opzionali) Tipo ritornato Corpo della funzione Parametri double max( double a, double b) { return (a>b) ? a : b; } Valore di ritorno • La lista dei parametri (anche se vuota) deve essere esplicitata • Il valore ritornato deve essere compatibile, a meno di conversione esplicita, con il tipo della funzione

Funzioni (2) Tipo di dichiarazione C++ commenti funzione double cube(double x) { return x*x*x; } parametri passati “by value” procedura void scrivi_quadrato(int i) { cout<<i*i<<endl; } subroutine, non si usa return senza argomenti void hello () { cout<<“Hello”<<endl; } puo` anche essere void hello(void) argomenti passati per riferimento void swap(int& i, int& j) { int t=i; i=j; j=t; } i e j hanno i loro valori scambiati variabile int scanf(const char, inline double cube(int x) codice inline argomenti di default int power(int i, int n=2) il 2 do argomento puo` essere tralasciato …) chiamata con un qualsiasi numero di argomenti

Prototipi delle funzioni • Prima di essere usata, una funzione deve essere dichiarata (nel file che la usa) main. cc max. cc #include <iostream> double max (double a, double b) double max(double, double); { int main() return (a>b) ? a : b; { } double m = max(1, 3); cout<<“Il massimo e` “<<m<<endl; Prototipo di max return 0; (normalmente in max. h) } • I prototipi rendono le funzioni in C++ “type safe”, nel senso che i valori reali degli argomenti vengono all’occorrenza convertiti nei tipi formali specificati dal prototipo

Chiamata per valore • Con il passaggioper valore la funzione non può modificare il valore dei suoi argomenti bool greater(int i, int j) { // se i>j scambia i e j if (i>j) { int temp=i; Argomenti passati “per valore” i=j; sono scambiati nella funzione ma j=temp; nel programma chiamante hanno return true; i valori vecchi } else return false; } – Es: int i = 5, j=7; – Dopo la chiamata di greater (i, j) – i vale sempre 5 e j vale sempre 7

Puntatori come parametri • L’uso dei puntatori permette ad una funzione di modificare il valore dei suoi argomenti bool greater(int *p 1, int *p 2) { /* se il valore puntato da p 1 > valore puntato da p 2 scambia i due valori*/ if (*p 1>*p 2) { int temp=*p 1; Se passo i puntatori le modifiche *p 1=*p 2; Hanno effetto sul programma *p 2=temp; chiamante return true; } else return false; } – Es: int i = 5, j=7; – Dopo la chiamata di greater (&i, &j) – i varrà 7 e j 5

Chiamata per riferimento • L’uso dei riferimenti permette ad una funzione di modificare il valore dei suoi argomenti bool greater(int& i, int& j) { // se i>j scambia i e j if (i>j) { int temp=i; Argomenti passati “by reference” i=j; possono essere modificati dalla j=temp; funzione stessa return true; } else return false; } – Con i riferimenti è sufficiente chiamare greater (i, j); – Per ragioni di efficenza, oggetti di grandi dimensioni (in termini di memoria) vengono normalmente passati “by reference”. – Per evitare che possano essere modificati dalla funzione, il riferimento viene definito const

Funzioni inline • La keyword inline suggerisce al compilatore che ogni chiamata alla funzione deve essere convertita in codice eseguibile (la definizione della funzione viene sostituita alla chiamata dovunque nell codice) • Le funzioni inline vengono usate per ragioni di efficienza e (per non sovraccaricare il compilatore) devono essere semplici • Il compilatore può decidere autonomamente (per esempio se la funzione è troppo lunga) di ignorare la direttiva inline

Argomenti di default • Ad ogni parametro di una funzione può essere assegnato un valore di default. Questo permette di chiamare la funzione tralasciando quei parametri il cui valore di default risulta appropriato main. cc pow. cc int pow(int , int); int main() { int r=3; int a 1=pow(3, 3); int a 2=pow(3); return 0; } // a 1=27 // a 2=9 int pow (int a, int k=2) { if (k==2) return a*a; else return a*pow(a, k-1); } Argomento di default • Solo ai parametri più a destra nella calling sequence può essere dato un default.

Overloading • Funzioni diverse possono avere lo stesso nome • La funzione che viene chiamata è scelta dal compilatore in base al tipo di ritorno ed al numero e tipo degli argomenti average_array. cc double media_array(const int a[], int size) { int sum=0; for (int i=0; i<size; i++) sum+=a[i]; return double(sum)/size; } double media_array(const double a[], int size) { double sum=0; for (int i=0; i<size; i++) sum+=a[i]; return sum/size; }

Overloading (2) • La lista dei tipi degli argomenti di una funzione è chiamata signature • Il tipo ritornato dalla funzione non fa parte della signature, mentre il numero e l’ordine degli argomenti è cruciale void print(int i=0) {. . . } // (1) void print(int i, double x) {. . . } // (2) void print(double y, int i) {. . . } // (3). . . print(‘A’); // ‘A’ e` convertito a int, chiama (1) print(str[]); // errore! Non e` possibile una conversione print(15, 9); // errore! Ambiguita` fra (2) e (3) print(15, 9. ); // OK, chiama (2) print(); // OK, chiama (1) con il default

I tentativi del compilatore L’algoritmo di selezione Ricerca della corrispondenza esatta Promozioni standard degli argomenti int long Conversioni standard dei tipi int float Conversioni definite dall’utente traccia int • L’utente può sempre utilizzare una conversione forzata (type cast) per ottenere una corrispondenza • Il compilatore segnala tutti i casi in cui esiste ambiguità