Maîtriser les fonctions en C : Exemples pratiques de récursivité et fonctions inline

Qu'est-ce qu'une fonction en C ?

Une fonction en programmation C est un bloc de code réutilisable qui rend un programme plus facile à comprendre, tester et modifier sans changer le programme appelant. Les fonctions divisent le code et modularisent le programme pour de meilleurs résultats plus efficaces. En bref, un programme plus large est divisé en divers sous-programmes appelés fonctions.

Quand vous divisez un grand programme en diverses fonctions, il devient facile de gérer chaque fonction individuellement. Chaque fois qu'une erreur se produit dans le programme, vous pouvez facilement investiguer les fonctions défaillantes et corriger seulement ces erreurs. Vous pouvez facilement appeler et utiliser les fonctions quand elles sont requises, ce qui entraîne automatiquement un gain de temps et d'espace.

Dans ce tutoriel, vous apprendrez :

• Fonctions bibliothèque vs fonctions utilisateur
• Déclaration de fonction
• Définition de fonction
• Appel de fonction
• Arguments de fonction
• Portée des variables
• Variables statiques
• Fonctions récursives
• Fonctions inline

Fonctions bibliothèque vs fonctions définies par l'utilisateur

Tout programme « C » a au moins une fonction qui est la fonction main, mais un programme peut avoir n'importe quel nombre de fonctions. La fonction main() en C est le point de départ d'un programme.

En programmation « C », les fonctions sont divisées en deux types :

1. Fonctions bibliothèque
2. Fonctions définies par l'utilisateur

La différence entre les fonctions bibliothèque et les fonctions définies par l'utilisateur en C est que nous n'avons pas besoin d'écrire du code pour une fonction bibliothèque. Elle est déjà présente dans le fichier d'en-tête que nous incluons toujours au début d'un programme. Vous n'avez qu'à taper le nom de la fonction et l'utiliser avec la syntaxe appropriée. Printf, scanf sont des exemples de fonctions bibliothèque.

Alors qu'une fonction définie par l'utilisateur est un type de fonction dans lequel nous devons écrire le corps de la fonction et appeler la fonction chaque fois que nous avons besoin qu'elle effectue une opération dans notre programme.

Une fonction définie par l'utilisateur en C est toujours écrite par l'utilisateur, mais plus tard elle peut devenir partie de la bibliothèque « C ». C'est un avantage majeur de la programmation « C ».

Les fonctions de programmation C sont divisées en trois activités :

1. Déclaration de fonction
2. Définition de fonction
3. Appel de fonction

Déclaration de fonction

La déclaration de fonction signifie écrire le nom d'un programme. C'est une partie obligatoire pour utiliser les fonctions dans le code. Dans une déclaration de fonction, nous spécifions juste le nom d'une fonction que nous allons utiliser dans notre programme comme une déclaration de variable. Nous ne pouvons pas utiliser une fonction à moins qu'elle ne soit déclarée dans un programme. Une déclaration de fonction est aussi appelée « prototype de fonction ».

Les déclarations de fonction (appelées prototype) sont généralement faites au-dessus de la fonction main() et prennent la forme générale :

type_retour nom_fonction (type_données arguments);

• Le type_retour : est le type de données de la valeur que la fonction retourne à l'instruction appelante.
• Le nom_fonction : est suivi de parenthèses.
• Arguments : noms avec leurs déclarations de type de données optionnellement placés à l'intérieur des parenthèses.

Considérons le programme suivant qui montre comment déclarer une fonction cube pour calculer la valeur cube d'une variable entière :

#include <stdio.h>
/*Déclaration de fonction*/
int add(int a,b);
/*Fin de déclaration de fonction*/
int main() {

Gardez à l'esprit qu'une fonction ne retourne pas nécessairement une valeur. Dans ce cas, le mot-clé void est utilisé.

Par exemple, la déclaration de la fonction output_message indique que la fonction ne retourne pas de valeur : void output_message();

Définition de fonction

La définition de fonction signifie simplement écrire le corps d'une fonction. Un corps de fonction consiste en des instructions qui vont effectuer une tâche spécifique. Un corps de fonction consiste en une instruction unique ou un bloc d'instructions. C'est aussi une partie obligatoire d'une fonction.

int add(int a,int b) //corps de fonction
{
    int c;
    c=a+b;
    return c;
}

Appel de fonction

Un appel de fonction signifie appeler une fonction chaque fois qu'elle est requise dans un programme. Chaque fois que nous appelons une fonction, elle effectue une opération pour laquelle elle a été conçue. Un appel de fonction est une partie optionnelle d'un programme.

result = add(4,5);

Voici le code complet :

#include <stdio.h>
int add(int a, int b); //déclaration de fonction
int main() {
    int a=10,b=20;
    int c=add(10,20); //appel de fonction
    printf("Addition:%d\n",c);
    getch();
}
int add(int a,int b) //corps de fonction
{
    int c;
    c=a+b;
    return c;
}

Sortie :

Addition:30

Arguments de fonction

Les arguments d'une fonction sont utilisés pour recevoir les valeurs nécessaires par l'appel de fonction. Ils sont correspondus par position ; le premier argument est passé au premier paramètre, le second au second paramètre, etc.

Par défaut, les arguments sont passés par valeur dans lequel une copie des données est donnée à la fonction appelée. La variable réellement passée ne changera pas.

Considérons le programme suivant qui démontre les paramètres passés par valeur :

int add (int x, int y);
int main() {
    int a, b, result;
    a = 5;
    b = 10;
    result = add(a, b);
    printf("%d + %d = %d\n", a, b, result);
    return 0;
}
int add (int x, int y) {
    x += y;
    return(x);
}

La sortie du programme est :

5 + 10 = 15

Gardez à l'esprit que les valeurs de a et b passées à la fonction add n'ont pas été changées car seule sa valeur a été passée dans le paramètre x.

Portée des variables

La portée des variables signifie la visibilité des variables dans le code du programme.

En C, les variables déclarées à l'intérieur d'une fonction sont locales à ce bloc de code et ne peuvent pas être référencées en dehors de la fonction. Cependant, les variables déclarées en dehors de toutes les fonctions sont globales et accessibles depuis l'ensemble du programme. Les constantes déclarées avec un #define au début d'un programme sont accessibles depuis l'ensemble du programme. Considérons le programme suivant qui affiche la valeur de la variable globale à partir de main et de la fonction définie par l'utilisateur :

#include <stdio.h>
int global = 1348;
void test();
int main() {
    printf("from the main function : global =%d \n", global);
    test () ;
    return 0;
}
void test (){
    printf("from user defined function : global =%d \n", global);
}

Résultat :

from the main function : global =1348
from user defined function : global =1348

Nous discutons les détails du programme :

1. Nous déclarons une variable globale entière avec 1348 comme valeur initiale.
2. Nous déclarons et définissons une fonction test() qui ne prend ni arguments ni ne retourne de valeur. Cette fonction imprime seulement la valeur de la variable globale pour démontrer que les variables globales peuvent être accédées n'importe où dans le programme.
3. Nous affichons la variable globale dans la fonction main.
4. Nous appelons la fonction test afin d'afficher la valeur de la variable globale.

En C, quand des arguments sont passés aux paramètres de fonction, les paramètres agissent comme des variables locales qui seront détruites en sortant de la fonction.

Quand vous utilisez des variables globales, utilisez-les avec prudence car elles peuvent entraîner des erreurs et peuvent changer n'importe où dans un programme. Elles doivent être initialisées avant utilisation.

Variables statiques

Les variables statiques ont une portée locale. Cependant, elles ne sont pas détruites en sortant de la fonction. Par conséquent, une variable statique conserve sa valeur pour toujours et peut être accédée quand la fonction est ré-entrée. Une variable statique est initialisée quand elle est déclarée et nécessite le préfixe static.

Le programme suivant utilise une variable statique :

#include <stdio.h>
void say_hi();
int main() {
    int i;
    for (i = 0; i < 5; i++) {
        say_hi();
    }
    return 0;
}
void say_hi() {
    static int calls_number = 1;
    printf("Hi number %d\n", calls_number);
    calls_number ++;
}

Le programme affiche :

Hi number 1
Hi number 2
Hi number 3
Hi number 4
Hi number 5

Fonctions récursives

Considérez le factoriel d'un nombre qui est calculé comme suit 6! = 6 * 5 * 4 * 3 * 2 * 1.

Ce calcul est fait en calculant répétitivement fact * (fact - 1) jusqu'à ce que fact égale 1.

Une fonction récursive est une fonction qui s'appelle elle-même et inclut une condition de sortie afin de terminer les appels récursifs. Dans le cas du calcul du factoriel, la condition de sortie est fact égale à 1. La récursion fonctionne en « empilant » les appels jusqu'à ce que la condition de sortie soit vraie.

Par exemple :

#include <stdio.h>
int factorial(int number);
int main() {
    int x = 6;
    printf("The factorial of %d is %d\n", x, factorial(x));
    return 0;
}
int factorial(int number) {
    if (number == 1)
        return (1); /* condition de sortie */
    else
        return (number * factorial(number - 1));
}

Le programme affiche :

The factorial of 6 is 720

Voici les détails du programme :

1. Nous déclarons notre fonction factorielle récursive qui prend un paramètre entier et retourne le factoriel de ce paramètre. Cette fonction s'appellera elle-même et diminuera le nombre jusqu'à ce que la condition de sortie, ou condition de base, soit atteinte. Quand la condition est vraie, les valeurs précédemment générées seront multipliées entre elles, et la valeur finale du factoriel est retournée.
2. Nous déclarons et initialisons une variable entière avec la valeur « 6 » et affichons ensuite sa valeur factorielle en appelant notre fonction factorielle.

Considérez le graphique suivant pour mieux comprendre le mécanisme récursif qui consiste à appeler la fonction elle-même jusqu'à ce que le cas de base ou condition d'arrêt soit atteint, et après cela, nous collectons les valeurs précédentes :

Fonctions inline

La fonction en programmation C est utilisée pour stocker les instructions les plus fréquemment utilisées. Elle est utilisée pour modulariser le programme.

Chaque fois qu'une fonction est appelée, le pointeur d'instruction saute à la définition de la fonction. Après l'exécution d'une fonction, le pointeur d'instruction revient à l'instruction d'où il a sauté vers la définition de la fonction.

Chaque fois que nous utilisons des fonctions, nous avons besoin d'une tête de pointeur supplémentaire pour sauter à la définition de la fonction et revenir à l'instruction. Pour éliminer le besoin de telles têtes de pointeur, nous utilisons les fonctions inline.

Dans une fonction inline, un appel de fonction est directement remplacé par le code de programme réel. Il ne saute vers aucun bloc car toutes les opérations sont effectuées à l'intérieur de la fonction inline.

Les fonctions inline sont principalement utilisées pour de petits calculs. Elles ne conviennent pas quand de gros calculs sont impliqués.

Une fonction inline est similaire à la fonction normale sauf que le mot-clé inline est placé avant le nom de la fonction. Les fonctions inline sont créées avec la syntaxe suivante :

inline nom_fonction () {
    //définition de fonction
}

Écrivons un programme pour implémenter une fonction inline.

inline int add(int a, int b) //déclaration fonction inline
{
    return(a+b);
}
int main() {
    int c=add(10,20);
    printf("Addition:%d\n",c);
    getch();
}

Sortie :

Addition: 30

Le programme ci-dessus démontre l'utilisation d'une fonction inline pour l'addition de deux nombres. Comme nous pouvons le voir, nous avons retourné l'addition de deux nombres dans la fonction inline seulement sans écrire de lignes supplémentaires. Lors de l'appel de fonction, nous avons juste passé les valeurs sur lesquelles nous devons effectuer l'addition.

Résumé

• Une fonction est un mini-programme ou un sous-programme.
• Les fonctions sont utilisées pour modulariser le programme.
• Bibliothèque et utilisateur-sont deux types de fonctions.
• Une fonction consiste en une déclaration, un corps de fonction, et une partie d'appel de fonction.
• La déclaration de fonction et le corps sont obligatoires.
• Un appel de fonction peut être optionnel dans un programme.
• Le programme C a au moins une fonction ; c'est la fonction main().
• Chaque fonction a un nom, type de donnée de valeur de retour ou void, paramètres.
• Chaque fonction doit être définie et déclarée dans votre programme C.
• Gardez à l'esprit que les variables ordinaires dans une fonction C sont détruites dès que nous sortons de l'appel de fonction.
• Les arguments passés à une fonction ne seront pas changés car ils sont passés par valeur, pas par adresse.
• La portée des variables est référée comme la visibilité des variables dans un programme.
• Il y a des variables globales et locales en programmation C.