C Academy · Lección

Evitar el desbordamiento de pila

Mantenga acotada la recursión

Evitar el desbordamiento de pila es una lección gratuita de C Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C Academy incluye 4 lecciones en total.

¿Qué es un desbordamiento de pila?

La pila de llamadas tiene un tamaño limitado. Cada llamada a una función utiliza parte de ella para los parámetros y las variables locales.

Si la recursión alcanza demasiada profundidad, la pila se llena y el programa se bloquea con un desbordamiento de pila.

Falta el caso base

La causa más común es que nunca se alcanza el caso base. Esto crea un bucle infinito y desborda la pila.

No ejecute este tipo de función; estudie por qué falla.

int broken(int n) {
    /* no base case: never stops */
    return broken(n + 1);
}

El argumento no se reduce

Incluso con un caso base, el argumento debe avanzar hacia él. Aquí n aumenta, por lo que nunca llega a 0.

Compruebe siempre que cada llamada se acerque a la condición de parada.

int oops(int n) {
    if (n == 0) return 0;
    return oops(n + 1); /* wrong direction */
}

Una versión correcta

Corregir la dirección hace que la función termine. Ahora n disminuye hacia el caso 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;
}

Los límites de profundidad son reales

Incluso una recursión correcta puede desbordar la pila si es muy profunda. Llamar a una función con millones de niveles de profundidad puede superar la capacidad de la pila, que a menudo es de tan solo unos megabytes.

Para profundidades enormes, prefiera la iteración.

Convertir una recursión profunda en un bucle

Si la profundidad de la recursión crece con el tamaño de la entrada, cambie a un bucle. Así evita acumular miles de marcos.

El bucle siguiente suma de 1 a un valor n grande de forma segura y con memoria 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;
}

Reducir la profundidad con divide y vencerás

Dividir el trabajo por la mitad mantiene pequeña la profundidad. Sumar un intervalo dividiéndolo por la mitad hace que la profundidad crezca como el logaritmo del tamaño, en lugar de linealmente.

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

Tenga cuidado con los arrays locales grandes

Las variables locales grandes hacen que cada marco sea más pesado, por lo que la pila se llena más rápido.

Evite declarar arrays grandes dentro de una función recursiva; pase punteros o utilice el heap.

void heavy(int n) {
    int buffer[10000]; /* big frame each call */
    if (n == 0) return;
    heavy(n - 1);
}

Utilizar un acumulador

Pasar un total acumulado como acumulador mantiene pequeño cada marco y da a la recursión una estructura de recursión de cola.

Algunos compiladores pueden reutilizar entonces un único marco.

#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;
}

Lista de comprobación de seguridad

Antes de confiar en una función recursiva, compruebe:

1. ¿Existe un caso base?
2. ¿Cada llamada avanza hacia él?
3. ¿Podría la profundidad ser enorme con una entrada grande?

Si la profundidad puede crecer sin control, utilice un bucle.

Probar con entradas pequeñas

Pruebe siempre la recursión primero con entradas muy pequeñas que pueda verificar manualmente.

Si los casos pequeños funcionan y la profundidad se mantiene acotada, podrá ampliar la escala con confianza.

Comprobación rápida

Detecte la solución más segura.

Resumen

El desbordamiento de pila ocurre cuando la recursión alcanza demasiada profundidad o nunca termina. Proporcione siempre un caso base alcanzable, reduzca el argumento en cada llamada, mantenga ligeros los marcos y cambie a la iteración cuando la profundidad pueda crecer con el tamaño de la entrada.

Preguntas frecuentes

¿La lección «Evitar el desbordamiento de pila» es gratis?

Sí — el texto completo de «Evitar el desbordamiento de pila» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C Academy, actualiza a CoddyKit PRO. El curso de C Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Evitar el desbordamiento de pila»?

Mantenga acotada la recursión Practicas C Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C Academy?

No se requiere experiencia previa. C Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Evitar el desbordamiento de pila»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C Academy?

Sí. Cada lección de C Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a C Academy