Éviter le dépassement de pile
Limitez la profondeur de la récursion.
Éviter le dépassement de pile est une leçon C Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C Academy comprend 4 leçons au total.
Qu’est-ce qu’un débordement de pile ?
La pile d’appels a une taille limitée. Chaque appel de fonction en utilise une partie pour les paramètres et les variables locales.
Si la récursion devient trop profonde, la pile se remplit et le programme s’arrête avec un débordement de pile.
Cas de base manquant
La cause la plus courante est un cas de base qui n’est jamais atteint. La fonction boucle alors indéfiniment et fait déborder la pile.
N’exécutez pas ce type de fonction ; étudiez plutôt pourquoi elle échoue.
int broken(int n) {
/* no base case: never stops */
return broken(n + 1);
}Argument qui ne diminue pas
Même avec un cas de base, l’argument doit progresser vers celui-ci. Ici, n augmente et n’atteint donc jamais 0.
Vérifiez toujours que chaque appel se rapproche de la condition d’arrêt.
int oops(int n) {
if (n == 0) return 0;
return oops(n + 1); /* wrong direction */
}Une version correcte
Corriger la direction permet à la fonction de s’arrêter. Maintenant, n diminue jusqu’au cas de base 0.
#include <stdio.h>
int good(int n) {
if (n == 0) return 0;
return n + good(n - 1);
}
int main(void) {
printf("%d\n", good(10));
return 0;
}Les limites de profondeur sont bien réelles
Même une récursion correcte peut provoquer un débordement si elle est très profonde. Appeler une fonction sur des millions de niveaux peut dépasser la capacité de la pile, qui ne fait souvent que quelques mégaoctets.
Pour les profondeurs très importantes, préférez l’itération.
Convertir une récursion profonde en boucle
Si la profondeur de récursion augmente avec la taille de l’entrée, remplacez-la par une boucle. Vous éviterez ainsi d’empiler des milliers de trames.
La boucle ci-dessous additionne les nombres de 1 à un n élevé en toute sécurité, avec une mémoire constante.
#include <stdio.h>
int main(void) {
long total = 0;
for (int i = 1; i <= 1000000; i++)
total += i;
printf("%ld\n", total);
return 0;
}Réduire la profondeur par diviser pour régner
Partager le travail en deux maintient une faible profondeur. Additionner un intervalle en le divisant par deux fait croître la profondeur comme le logarithme de la taille, plutôt que linéairement.
long range_sum(int lo, int hi) {
if (lo == hi) return lo;
int mid = (lo + hi) / 2;
return range_sum(lo, mid) + range_sum(mid + 1, hi);
}Surveiller les grands tableaux locaux
De grandes variables locales rendent chaque trame lourde, ce qui remplit la pile plus rapidement.
Évitez de déclarer de grands tableaux dans une fonction récursive ; transmettez plutôt des pointeurs ou utilisez le tas.
void heavy(int n) {
int buffer[10000]; /* big frame each call */
if (n == 0) return;
heavy(n - 1);
}Utiliser un accumulateur
Transmettre un total courant comme accumulateur maintient chaque trame à une petite taille et donne à la récursion une forme terminale.
Certains compilateurs peuvent alors réutiliser une seule trame.
#include <stdio.h>
long sum_acc(int n, long acc) {
if (n == 0) return acc;
return sum_acc(n - 1, acc + n);
}
int main(void) {
printf("%ld\n", sum_acc(100, 0));
return 0;
}Liste de contrôle de sécurité
Avant de faire confiance à une fonction récursive, vérifiez :
1. Existe-t-il un cas de base ?
2. Chaque appel s’en rapproche-t-il ?
3. La profondeur peut-elle devenir très importante avec une grande entrée ?
Si la profondeur risque d’exploser, utilisez plutôt une boucle.
Tester avec de petites entrées
Testez toujours d’abord la récursion avec de très petites entrées que vous pouvez vérifier à la main.
Si les petits cas fonctionnent et que la profondeur reste limitée, vous pouvez augmenter l’échelle en toute confiance.
Vérification rapide
Trouvez la correction la plus sûre.
Récapitulatif
Un débordement de pile se produit lorsque la récursion devient trop profonde ou ne s’arrête jamais. Fournissez toujours un cas de base atteignable, réduisez l’argument à chaque appel, gardez les trames légères et passez à l’itération lorsque la profondeur peut augmenter avec la taille de l’entrée.
Questions Fréquemment Posées
La leçon « Éviter le dépassement de pile » est-elle gratuite ?
Oui — le texte complet de « Éviter le dépassement de pile » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C Academy, passe à CoddyKit PRO. Le cours C Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Éviter le dépassement de pile » ?
Limitez la profondeur de la récursion. Tu pratiques C Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer C Academy ?
Aucune expérience préalable n'est requise. C Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « Éviter le dépassement de pile » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon C Academy ?
Oui. Chaque leçon C Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Comment fonctionne la récursion
- Problèmes récursifs classiques
- Récursion ou itération
- Éviter le dépassement de pile