Quel que soit le langage de programmation que vous utilisez, au fur et à mesure que vous commencez à coder, vous apprenez des concepts qui rendent votre code clair et facile à lire/comprendre. Il existe également plusieurs concepts de ce type dans le C. L'une d'entre elles est les "fonctions récursives", dont nous parlerons ici dans cet article.
Une fonction récursive est une fonction qui s'appelle elle-même. L'appel peut être effectué directement depuis le corps de la fonction, ou indirectement depuis une autre fonction appelée par la fonction en question.
Voici un exemple de récursivité directe :
int func (int a)
{
//statements
func(a-1);
// statements
return 0;
}
Et voici un exemple de récursivité indirecte :
int func (int a)
{
//statements
func_new(a);
// statements
return 0;
}
int func_new(int b)
{
//statements
func(b-1);
//statementsur
return 0;
}
Comme déjà mentionné au début, la récursivité vous aide à obtenir un code compact, non seulement facile à écrire, mais également facile à comprendre et à réviser. Prenons un exemple pour rendre cet avantage plus clair.
Je suis sûr que vous avez tous dû entendre parler du concept de factorielle. Pour ceux qui ne le savent pas, la factorielle est le résultat que vous obtenez lorsque vous multipliez un entier par tous les entiers positifs inférieurs à celui-ci. Par exemple, la factorielle de 5 est 5x4x3x2x1, ce qui équivaut à 120.
Voici un code simple pour trouver la factorielle d'un nombre :
#include <stdio.h>
int main()
{
int a = 0, i = 0, fact = 1;
printf("Enter a number: ");
scanf("%d", &a);
for(i=1; i<=a; i++)
{
fact = fact * i;
}
printf("Factorial of the number is: %d ", fact);
return 0;
}
Notez que ce code est juste pour vous faire savoir comment la factorielle d'un nombre peut être calculée via un programme C. Le programme ne prend pas en compte les cas extrêmes qui peuvent affecter la précision du résultat qu'il produit.
C'est donc l'une des nombreuses façons dont vous pouvez calculer la factorielle d'un nombre sans utiliser de fonction récursive. Voyons maintenant un morceau de code qui utilise la récursivité pour calculer une factorielle.
#include <stdio.h>
int factorial (int b)
{
if(!b)
return 1;
return (b * factorial(b-1));
}
int main()
{
int a = 0, fact = 1;
printf("Enter a number: ");
scanf("%d", &a);
fact = factorial(a);
printf("Factorial of the number is: %d ", fact);
return 0;
}
Vous pouvez donc voir que la fonction "factorielle" qui calcule en fait la factorielle est très compacte. Et si vous faites bien attention, c'est aussi très facile à comprendre.
Pour ceux qui ne savent pas ce qui se passe, la valeur que l'utilisateur a saisie, disons 5, est transmise à la fonction "factorielle" lorsqu'elle est appelée pour la première fois depuis la fonction "principale". Dans la fonction 'factorielle', il y a une vérification pour voir si la valeur d'entrée est zéro, ce qui n'est pas vrai lorsque la fonction est appelée pour la première fois avec la valeur d'entrée '5'.
Ensuite, l'instruction de retour contient une expression qui multiplie 5 par la valeur de retour de 'factorial(4)'. Alors maintenant, la fonction 'factorielle' s'exécute à nouveau, et nous atteignons l'expression suivante :return (4 * factorial(3)). Et puis encore ces étapes se répètent.
Donc, si vous regardez globalement, voici comment ces appels de fonction sont empilés :
- 5 * factoriel(4)
- 4 * factoriel(3)
- 3 * factoriel(2)
- 2 * factoriel (1)
- 1 * factoriel (0)
Désormais, lorsque factorial(0) s'exécute, la condition 'if' de la fonction 'factorial' devient vraie et la valeur '1' est renvoyée. Alors maintenant, voici comment les appels listés ci-dessus se terminent (comparez la dernière entrée de la liste précédente avec la première entrée de cette liste, et ainsi de suite) :
- 1 * 1
- 2 * (1*1)
- 3 * (2*(1*1))
- 4 * (3*(2*(1*1)))
- 5 * (4 * (3*(2*(1*1))))
Ce qui est effectivement 5 * 4 *3 * 2 * 1, qui à son tour est 120, le factoriel de 5.
C'est ainsi que fonctionnent les fonctions récursives. Bien qu'il n'y ait aucun doute sur les avantages de la fonction récursive que nous avons énumérés jusqu'à présent, il existe également des inconvénients.
Par exemple, dans notre exemple ci-dessus, jusqu'à ce que l'appel 'factorial(0)' soit terminé, tous les appels 'factoriels' précédents attendaient que le traitement de la fonction soit terminé. Sans oublier le fait que des variables automatiques ou locales occupent de la mémoire à chaque appel récursif effectué.
Il n'y a donc effectivement aucune économie d'espace de stockage lorsque vous utilisez la récursivité. De plus, il n'y a aucune garantie que votre code sera plus rapide à exécuter. Le véritable avantage d'une fonction récursive est lorsque vous traitez des structures de données, dont nous parlerons plus tard dans le cadre de cette série de didacticiels C en cours.
Conclusion
Pour conclure, bien que vous n'utilisiez pas fréquemment la fonction récursive dans vos tâches de codage quotidiennes, c'est un concept important dont vous devez être conscient. Essayez l'exemple que nous avons mentionné ici et modifiez-le pour mieux comprendre le concept de fonctions récursives.