Langage C

les fonctions en C

Une fonction est un ensemble d'instructions qui prennent des entrées, effectuent des calculs spécifiques et produisent une sortie.
L'idée est de regrouper certaines tâches effectuées de manière courante ou répétée et de créer une fonction permettant d'appeler la fonction au lieu d'écrire le même code encore et encore pour différentes entrées.

Exemple 1 :
                                // Un exemple de fonction qui prend deux paramètres 'a' et 'b' en entrée
                                // et retourne la somme de deux nombres en entrée
                                int somme(int a, int b){
                                    int c;
                                    c=a+b;
                                    return c;
                                }

                                // fonction principale 
                                int main()
                                {
                                    int a=5,b=3,s;
                                    s=somme(a,b);
                                    printf("la somme est : %d", s);
                                    return 0;
                                }
                            
la somme est : 8

Pourquoi avons-nous besoin de fonctions ?

  • Les fonctions nous aident à réduire la redondance du code. Si la fonctionnalité est exécutée à plusieurs endroits du logiciel, alors, plutôt que d'écrire le même code, encore et encore, nous créons une fonction et l'appelons partout. Cela facilite également la maintenance car nous devons changer à un seul endroit si nous apportons des modifications futures à la fonctionnalité.
  • Les fonctions rendent le code modulaire. Prenons un gros fichier comportant plusieurs lignes de codes. Il devient très simple de lire et d’utiliser le code si celui-ci est divisé en fonctions.

Déclaration de fonction

Une déclaration de fonction indique au compilateur le nombre de paramètres que prend la fonction, les types de données des paramètres et le type de retour de la fonction.
Mettre les noms de paramètres dans la déclaration de fonction est facultatif, mais il est nécessaire de les mettre dans la définition.

                                type_retour identificateur(paramètres)
                                {
                                    /* Instructions de la fonction */
                                }
                            
  • Type: le type de la valeur renvoyée;
  • Identificateur: le nom de la fonction;
  • Paramètres: la liste de paramètres.
Exemple 2 :
                                float somme(float, float);
                                int max(int, int);
                                int * echange(int *, int);
                                void afficher();
                            

Il est toujours recommandé de déclarer une fonction avant de l'utiliser.

En C, nous pouvons faire la déclaration et la définition au même endroit, comme dans l'exemple 1.

C permet également de déclarer et de définir des fonctions séparément, ce qui est particulièrement nécessaire dans le cas de fonctions de bibliothèque. Les fonctions de la bibliothèque sont déclarées dans les fichiers d’en-tête et définies dans les fichiers de la bibliothèque.

Exemple 3 :
                                int Min(int, int);               /* Déclaration de la fonction minimum */ 
                                int main(void){
                                    int a=2, b=3, i;               /* Fonction principale.*/ 
                                    i = Min(a,b); /* Appel à la fonction Min, déjà déclarée. */ 
                                    return 0; 
                                } 
                                  
                                int Min(int i, int j) {         /* Définition de la fonction min. */ 
                                    if (i< j) return i; 
                                    else return j;
                                } 
                            
Si une fonction ne renvoie pas de valeur, on lui donnera le type void. Si elle n’attend pas de paramètres, sa liste de paramètres sera void ou n’existera pas. Il n’est pas nécessaire de mettre une instruction return à la fin d’une fonction qui ne renvoie pas de valeur.

Passage de paramètres

Les paramètres passés à une function sont appelés paramètres réels. Par exemple, dans le programme ci-dessus, les paramètres 2 et 3 sont réels.
Les paramètres reçus par la fonction sont appelés paramètres formels. Par exemple, dans le programme ci-dessus, i et j sont des paramètres formels.
Il existe deux manières les plus courantes de passer des paramètres.

Passage par valeur

Lors du passage par valeur, les arguments sont copiés dans des objets temporaires qui sont crées lors du passage d'arguments et qui sont détruit à la fin de l'exécution de la fonction : toutes les modifications effectuées sur ces objets temporaires seront donc perdues à la fin de la fonction et n'auront aucune incidence sur l'objet passé en argument lors de l'appel de la fonction.

Exemple 4 :
                                void incremente(int i) 
                                { 
                                    i++; 
                                }
                                    
                                int main()
                                {
                                    int j = 12;
                                    incremente(j);
                                    printf(" j = ", j);
                                    return 0
                                } 
                            
  j = 12

l’échange n’a pas lieu

Passage par référence

Les paramètres réels et formels se réfèrent aux mêmes emplacements, de sorte que toute modification apportée à l'intérieur de la fonction est réellement reflétée dans les paramètres réels de l'appelant.
En C, les paramètres sont toujours passés par valeur. Par exemple. dans le code ci-dessus (exemple 4), la valeur de j n'est pas modifiée à l'aide de la fonction incremente ().

Cependant, en C, nous pouvons utiliser des pointeurs pour obtenir l’effet de passer par référence. Par exemple, considérons le programme ci-dessous (exemple 5). La fonction incremente() attend un pointeur i sur un entier (ou l'adresse d'un entier). Il modifie la valeur à l'adresse i. L'opérateur de déréférence * permet d'accéder à la valeur à une adresse. Dans l’instruction ‘(*i)++’ , la valeur de l’adresse i est icrémentée par 1.
L’opérateur d’adresse & est utilisé pour obtenir l’adresse d’une variable de tout type de données. Dans l'appel de la fonction  ‘incremente(&j)’, l’adresse de j est transmise afin que j puisse être modifiée à l’aide de son adresse.

Exemple 5 :
                                void incremente(int *i) 
                                { 
                                    (*i)++; 
                                }
                                    
                                int main()
                                {
                                    int j = 12;
                                    incremente(&j);
                                    printf(" j = ", j);
                                    return 0
                                } 
                            
  j = 13

Voici quelques points importants sur les fonctions en C.

  • Chaque programme C possède une fonction appelée main () appelée par le système d'exploitation lorsqu'un utilisateur exécute le programme.
  • Chaque fonction a un type de retour. Si une fonction ne renvoie aucune valeur, void est utilisé comme type de retour. De plus, si le type de retour de la fonction est vide, nous pouvons toujours utiliser l'instruction return dans le corps de la définition de la fonction en ne spécifiant aucune constante, variable, etc., en ne mentionnant que l'instruction 'return;' qui symboliserait la fin de la fonction comme indiqué ci-dessous:
    Exemple 5 :
                                            void afficher(int a){
                                                ... //Corps de la fonction
                                                return;
                                            }
                                        
  • En C, les fonctions peuvent renvoyer n'importe quel type sauf les tableaux et les fonctions. Nous pouvons contourner cette limitation en renvoyant pointeur à tableau ou pointeur à fonction.
  • Une liste de paramètres vide en C signifie que la liste de paramètres n'est pas spécifiée et que la fonction peut être appelée avec n'importe quel paramètre. En C, ce n'est pas une bonne idée de déclarer une fonction comme test() . Pour déclarer une fonction qui ne peut être appelée sans aucun paramètre, nous devons utiliser void void test(void).
    En C ++, liste vide signifie que la fonction ne peut être appelée que sans paramètre. En C ++, void test() et void test(void) sont identiques.
  • Si, dans un programme C, une fonction est appelée avant sa déclaration, le compilateur C assume automatiquement la déclaration de cette fonction de la manière suivante:
    int nom_fonction ();
    Et dans ce cas, si le type de retour de cette fonction est différent de int, le compilateur affichera une erreur.

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :