Fonctions en programmation C avec exemples : récursif et en ligne
Benjamin marcheur
⚡ Résumé intelligent
En langage C, les fonctions sont des blocs de code réutilisables qui divisent un programme volumineux en sous-programmes plus petits, facilitant ainsi sa compréhension, son test et sa modification. Chaque fonction comprend une déclaration, une définition et un appel.
Qu’est-ce qu’une fonction en C ?
Fonction en programmation C Une fonction est un bloc de code réutilisable qui simplifie la compréhension et le test d'un programme, et permet de le modifier facilement sans toucher au programme appelant. Les fonctions divisent le code et modularisent le programme pour des résultats plus performants. En bref, un programme complexe est divisé en sous-programmes appelés fonctions.
Lorsque vous divisez un gros programme en plusieurs fonctions, il devient facile de gérer chaque fonction individuellement. Chaque fois qu'une erreur se produit dans le programme, vous pouvez facilement rechercher les fonctions défectueuses et corriger uniquement ces erreurs. Vous pouvez facilement appeler et utiliser des fonctions chaque fois qu'elles sont nécessaires, ce qui entraîne automatiquement un gain de temps et d'espace.
Bibliothèque contre. Fonctions définies par l'utilisateur
Chaque programme « C » a au moins une fonction qui est la fonction principale, mais un programme peut avoir n'importe quel nombre de fonctions. La fonction main() en C est un point de départ d’un programme.
En programmation « C », les fonctions sont divisées en deux types :
- Les fonctions d une bibliothèque
- Les fonctions définies par l'utilisateur
La différence entre la bibliothèque et les fonctions définies par l'utilisateur en C est que nous n'avons pas besoin d'écrire de code pour une fonction de bibliothèque. Il est déjà présent dans le fichier d'en-tête que nous incluons toujours au début d'un programme. Il vous suffit de taper le nom d'une fonction et de l'utiliser avec la syntaxe appropriée. Printf, scanf sont des exemples de fonctions de bibliothèque.
Alors qu'une fonction définie par l'utilisateur est un type de fonction dans laquelle nous devons écrire le corps d'une 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 elle peut ultérieurement faire 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 telles que,
- Déclaration de fonction
- Définition de la fonction
- Appel de fonction
Déclaration de fonction
La déclaration d'une fonction consiste à indiquer son nom. C'est une étape indispensable pour utiliser des fonctions dans le code. Dans une déclaration de fonction, on spécifie simplement le nom de la fonction que l'on va utiliser dans le programme, comme pour la déclaration d'une variable. On ne peut pas utiliser une fonction sans l'avoir déclarée. Une déclaration de fonction est également appelée « prototype de fonction ».
Les déclarations de fonctions (appelées prototype) se font généralement au dessus de la fonction main() et prennent la forme générale :
return_data_type function_name (data_type arguments);
- Le type de données de retour (return_data_type) correspond au type de données de la fonction de valeur renvoyée à l'instruction appelante.
- Le nom de la fonction est suivi de parenthèses.
- Les noms des arguments, accompagnés de leurs déclarations de type de données, sont éventuellement placés entre parenthèses.
Nous considérons le programme suivant qui montre comment déclarer une fonction cube pour calculer la valeur cubique d'une variable entière
#include <stdio.h> /*Function declaration*/ int add(int a,b); /*End of Function declaration*/ int main() {
Gardez à l'esprit qu'une fonction ne renvoie 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 renvoie pas de valeur : void output_message();
Définition de la fonction
La définition d’une fonction consiste simplement à écrire le corps d’une fonction. Le corps d'une fonction est constitué d'instructions qui vont effectuer une tâche spécifique. Un corps de fonction se compose d’un seul ou d’un bloc d’instructions. C'est également un élément obligatoire d'une fonction.
int add(int a,int b) //function body { 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 facultative d’un programme.
result = add(4,5);
Voici le code complet :
#include <stdio.h> int add(int a, int b); //function declaration int main() { int a=10,b=20; int c=add(10,20); //function call printf("Addition:%d\n",c); getch(); } int add(int a,int b) //function body { 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 jumelés par poste ; le premier argument est passé au premier paramètre, le second au deuxième paramètre et ainsi de suite.
Par défaut, les arguments sont passés par valeur, ce qui permet de transmettre une copie des données à la fonction appelée. La variable effectivement passée reste inchangée.
Nous 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 ont été transmises à la fonction d'ajout n'ont pas été modifiées car seule sa valeur a été transmise au paramètre x.
Portée variable
La portée des variables signifie la visibilité des variables dans un 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 être accessibles depuis l'extérieur de la fonction. En revanche, les variables déclarées en dehors de toute fonction sont globales et accessibles depuis l'ensemble du programme. Les constantes déclarées avec `#define` en début de programme sont accessibles depuis l'ensemble du programme. Prenons l'exemple du programme suivant, qui affiche la valeur d'une variable globale depuis la fonction `main` et une 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 des détails du programme :
- Nous déclarons une variable globale entière avec 1348 comme valeur initiale.
- Nous déclarons et définissons une fonction test() qui ne prend ni d'arguments ni ne renvoie de valeur. Cette fonction imprime uniquement la valeur de la variable globale pour démontrer que les variables globales sont accessibles n'importe où dans le programme.
- Nous imprimons la variable globale dans la fonction principale.
- Nous appelons la fonction test afin d'imprimer la valeur de la variable globale.
En C, lorsque des arguments sont passés aux paramètres de la fonction, les paramètres agissent comme des variables locales qui seront détruites à la sortie de la fonction.
Lorsque vous utilisez variables globales, utilisez-les avec prudence car ils peuvent entraîner des erreurs et ils peuvent changer n'importe où dans un programme. Ils doivent être initialisés avant utilisation.
Variables statiques
Les variables statiques ont une portée locale. Ils ne sont cependant pas détruits à la sortie de la fonction. Par conséquent, une variable statique conserve sa valeur pour toujours et est accessible lorsque la fonction est ressaisie. Une variable statique est initialisée lorsqu'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érons la factorielle d'un nombre qui se calcule comme suit : 6! = 6 * 5 * 4 * 3 * 2 * 1.
Ce calcul est effectué en calculant à plusieurs reprises le fait * (fait -1) jusqu'à ce que le fait soit égal à 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 de nombres factoriels, la condition de sortie est en fait égale à 1. La récursivité 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); /* exiting condition */ else return (number * factorial(number - 1)); }
Le programme affiche :
The factorial of 6 is 720
Ici, nous discutons des détails du programme :
- Nous déclarons notre fonction factorielle récursive qui prend un paramètre entier et renvoie la factorielle de ce paramètre. Cette fonction s'appellera elle-même et diminuera le nombre jusqu'à ce que la condition de sortie ou la condition de base soit atteinte. Lorsque la condition est vraie, les valeurs générées précédemment seront multipliées les unes par les autres et la valeur factorielle finale est renvoyée.
- Nous déclarons et initialisons une variable entière avec la valeur « 6 », puis imprimons sa valeur factorielle en appelant notre fonction factorielle.
Le schéma suivant permet de mieux comprendre le mécanisme récursif, qui consiste à appeler la fonction elle-même jusqu'à ce que le cas de base ou l'arrêt soit atteint.ping La condition est atteinte, et après cela, nous récupérons les valeurs précédentes :
Fonctions en ligne
La fonction en programmation C est utilisée pour stocker les instructions les plus fréquemment utilisées. Il est utilisé pour modulariser le programme.
Chaque fois qu'une fonction est appelée, le pointeur d'instruction passe à la définition de la fonction. Après avoir exécuté une fonction, le pointeur d'instruction revient à l'instruction d'où il est passé à la définition de la fonction.
Chaque fois que nous utilisons des fonctions, nous avons besoin d'un supplément aiguille head pour passer à la définition de la fonction et revenir à l'instruction. Pour éliminer le besoin de telles têtes de pointeur, nous utilisons des fonctions en ligne.
Dans une fonction en ligne, un appel de fonction est directement remplacé par un code de programme réel. Il ne saute à aucun bloc car toutes les opérations sont effectuées à l'intérieur de la fonction en ligne.
Les fonctions en ligne sont principalement utilisées pour les petits calculs. Ils ne conviennent pas lorsqu’il s’agit de calculs de grande envergure.
Une fonction en ligne est similaire à la fonction normale, sauf que le mot-clé inline est placé avant le nom de la fonction. Les fonctions en ligne sont créées avec la syntaxe suivante :
inline function_name ()
{
//function definition
}
Écrivons un programme pour implémenter une fonction en ligne.
inline int add(int a, int b) //inline function declaration { 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 en ligne pour l'addition de deux nombres. Comme nous pouvons le voir, nous avons renvoyé l'addition sur deux nombres uniquement dans la fonction en ligne sans écrire de lignes supplémentaires. Lors de l'appel de fonction nous venons de transmettre des valeurs sur lesquelles nous devons effectuer une addition.
