Panoramica delle funzioni

In termini di programmazione, a functionè un blocco di istruzioni che esegue un'attività specifica. Le funzioni accettano dati, li elaborano e restituiscono un risultato. Le funzioni sono scritte principalmente per supportare il concetto di riusabilità. Una volta che una funzione è stata scritta, può essere chiamata facilmente, senza dover scrivere lo stesso codice ancora e ancora.

Linguaggi funzionali differenti usano una sintassi differente per scrivere una funzione.

Prerequisiti per la scrittura di una funzione

Prima di scrivere una funzione, un programmatore deve conoscere i seguenti punti:

Lo scopo della funzione dovrebbe essere noto al programmatore.
L'algoritmo della funzione dovrebbe essere noto al programmatore.
Le variabili di dati delle funzioni e il loro obiettivo dovrebbero essere noti al programmatore.
I dati della funzione dovrebbero essere noti al programmatore chiamato dall'utente.

Controllo del flusso di una funzione

Quando una funzione viene "chiamata", il programma "trasferisce" il controllo per eseguire la funzione e il suo "flusso di controllo" è il seguente:

Il programma raggiunge l'istruzione contenente una "chiamata di funzione".
Viene eseguita la prima riga all'interno della funzione.
Tutte le istruzioni all'interno della funzione vengono eseguite dall'alto verso il basso.
Quando la funzione viene eseguita con successo, il controllo torna all'istruzione da cui è partita.
Tutti i dati calcolati e restituiti dalla funzione vengono utilizzati al posto della funzione nella riga di codice originale.

Sintassi di una funzione

La sintassi generale di una funzione è la seguente:

returnType functionName(type1 argument1, type2 argument2, . . . ) {     
   // function body 
}

Definizione di una funzione in C ++

Facciamo un esempio per capire come una funzione può essere definita in C ++ che è un linguaggio di programmazione orientato agli oggetti. Il codice seguente ha una funzione che aggiunge due numeri e fornisce il risultato come output.

#include <stdio.h> 

int addNum(int a, int b);     // function prototype  

int main() {    
   int sum; 
   sum = addNum(5,6);         // function call 
   printf("sum = %d",sum); 
   return 0; 
}  
int addNum (int a,int b) {    // function definition      
   int result; 
   result = a + b; 
   return result;             // return statement 
}

Produrrà il seguente output:

Sum = 11

Definizione di una funzione in Erlang

Vediamo come la stessa funzione può essere definita in Erlang, che è un linguaggio di programmazione funzionale.

-module(helloworld).  
-export([add/2,start/0]).   

add(A,B) ->
   C = A + B,  
   io:fwrite("~w~n",[C]).  
start() ->  
   add(5,6).

Produrrà il seguente output:

Prototipo di funzione

Un prototipo di funzione è una dichiarazione della funzione che include il tipo di ritorno, il nome della funzione e l'elenco degli argomenti. È simile alla definizione di funzione senza funzione-corpo.

For Example - Alcuni linguaggi di programmazione supportano la prototipazione di funzioni e altri no.

In C ++, possiamo creare un prototipo di funzione della funzione 'sum' in questo modo:

int sum(int a, int b)

Note - Linguaggi di programmazione come Python, Erlang, ecc. Non supportano la prototipazione di funzioni, dobbiamo dichiarare la funzione completa.

Qual è l'uso del prototipo di funzione?

Il prototipo della funzione viene utilizzato dal compilatore quando viene chiamata la funzione. Il compilatore lo utilizza per garantire il tipo di ritorno corretto, l'elenco degli argomenti corretto e il tipo di ritorno corretto.

Firma della funzione

Una firma di funzione è simile al prototipo di funzione in cui il numero di parametri, il tipo di dati dei parametri e l'ordine di apparizione devono essere in ordine simile. Ad esempio -

void Sum(int a, int b, int c);         // function 1  
void Sum(float a, float b, float c);   // function 2  
void Sum(float a, float b, float c);   // function 3

Function1 e Function2 hanno firme diverse. Function2 e Function3 hanno le stesse firme.

Note - Il sovraccarico delle funzioni e l'override delle funzioni, che discuteremo nei capitoli successivi, si basano sul concetto di firme di funzione.

Il sovraccarico delle funzioni è possibile quando una classe ha più funzioni con lo stesso nome ma firme diverse.
L'override della funzione è possibile quando una funzione di classe derivata ha lo stesso nome e firma della sua classe base.