Aperçu des fonctions

En termes de programmation, un functionest un bloc d'instructions qui effectue une tâche spécifique. Les fonctions acceptent les données, les traitent et renvoient un résultat. Les fonctions sont écrites principalement pour prendre en charge le concept de réutilisabilité. Une fois qu'une fonction est écrite, elle peut être appelée facilement, sans avoir à écrire le même code encore et encore.

Différents langages fonctionnels utilisent une syntaxe différente pour écrire une fonction.

Conditions préalables à l'écriture d'une fonction

Avant d'écrire une fonction, un programmeur doit connaître les points suivants -

  • Le but de la fonction doit être connu du programmeur.

  • L'algorithme de la fonction doit être connu du programmeur.

  • Les variables de données des fonctions et leur objectif doivent être connus du programmeur.

  • Les données de la fonction doivent être connues du programmeur appelé par l'utilisateur.

Contrôle de flux d'une fonction

Lorsqu'une fonction est "appelée", le programme "transfère" le contrôle pour exécuter la fonction et son "flux de contrôle" est comme ci-dessous -

  • Le programme atteint l'instruction contenant un "appel de fonction".

  • La première ligne à l'intérieur de la fonction est exécutée.

  • Toutes les instructions à l'intérieur de la fonction sont exécutées de haut en bas.

  • Lorsque la fonction est exécutée avec succès, le contrôle revient à l'instruction d'où il a commencé.

  • Toutes les données calculées et renvoyées par la fonction sont utilisées à la place de la fonction dans la ligne de code d'origine.

Syntaxe d'une fonction

La syntaxe générale d'une fonction se présente comme suit -

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

Définition d'une fonction en C ++

Prenons un exemple pour comprendre comment une fonction peut être définie en C ++ qui est un langage de programmation orienté objet. Le code suivant a une fonction qui ajoute deux nombres et fournit son résultat comme sortie.

#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 
}

Il produira la sortie suivante -

Sum = 11

Définition d'une fonction dans Erlang

Voyons comment la même fonction peut être définie dans Erlang, qui est un langage de programmation fonctionnel.

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

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

Il produira la sortie suivante -

11

Prototype de fonction

Un prototype de fonction est une déclaration de la fonction qui inclut le type de retour, le nom de la fonction et la liste des arguments. C'est similaire à la définition de fonction sans corps de fonction.

For Example - Certains langages de programmation prennent en charge le prototypage de fonctions et certains ne le sont pas.

En C ++, nous pouvons créer un prototype de fonction de la fonction 'somme' comme ceci -

int sum(int a, int b)

Note - Les langages de programmation comme Python, Erlang, etc. ne prennent pas en charge le prototypage de fonction, nous devons déclarer la fonction complète.

À quoi sert le prototype de fonction?

Le prototype de fonction est utilisé par le compilateur lorsque la fonction est appelée. Le compilateur l'utilise pour s'assurer que le type de retour est correct, que la liste d'arguments appropriée est transmise et que leur type de retour est correct.

Signature de fonction

Une signature de fonction est similaire au prototype de fonction dans lequel le nombre de paramètres, le type de données des paramètres et l'ordre d'apparition doivent être dans un ordre similaire. Par exemple -

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 et Function2 ont des signatures différentes. Function2 et Function3 ont les mêmes signatures.

Note - La surcharge de fonction et le remplacement de fonction dont nous parlerons dans les chapitres suivants sont basés sur le concept de signatures de fonction.

  • La surcharge de fonctions est possible lorsqu'une classe a plusieurs fonctions avec le même nom mais des signatures différentes.

  • Le remplacement de fonction est possible lorsqu'une fonction de classe dérivée a le même nom et la même signature que sa classe de base.