Fonctions en programmation C avec exemples : récursif et en ligne

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

Fonction en programmation C est un bloc de code réutilisable qui rend un programme plus facile à comprendre, à tester et qui peut être facilement modifié sans changer le programme appelant. Les fonctions divisent le code et modularisent le programme pour des résultats meilleurs et efficaces. En bref, un programme plus vaste est divisé en différents 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 :

Fonctions de la bibliothèque
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 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 précisons simplement le nom d'une fonction que nous allons utiliser dans notre programme comme une déclaration de variable. Nous ne pouvons utiliser une fonction que si elle est déclarée dans un programme. Une déclaration de fonction est également appelée « Fonction prototype. »

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);

Votre partenaire return_data_type: est le type de données de la fonction de valeur renvoyée à l'instruction appelante.
Votre partenaire nom_fonction: est suivi de parenthèses
Arguments les noms avec 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 dans lequel une copie des données est donnée à la fonction appelée. La variable réellement passée ne changera pas.

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 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. Constantes déclarées avec un #define en haut d'un programme sont accessibles depuis l'ensemble du programme. Nous considérons le programme suivant qui imprime la valeur de la variable globale à partir de la fonction principale 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 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 est calculée 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.

Considérez le tableau 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 la condition d'arrêt soit atteinte, et après cela, nous collectons 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();
}