C Academy · Lesson

Avoiding Stack Overflow

Keep recursion bounded.

Avoiding Stack Overflow is a free C Academy lesson on CoddyKit — lesson 4 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the C Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

What Is A Stack Overflow?

The call stack has a limited size. Each function call uses part of it for parameters and locals.

If recursion goes too deep, the stack fills up and the program crashes with a stack overflow.

Missing Base Case

The most common cause is a base case that is never reached. This loops forever and overflows the stack.

Do not run this kind of function; study why it fails.

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

Argument Not Shrinking

Even with a base case, the argument must move toward it. Here n increases, so it never reaches 0.

Always check that each call gets closer to the stopping condition.

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

A Correct Version

Fixing the direction makes it terminate. Now n decreases toward the base case 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;
}

Depth Limits Are Real

Even correct recursion can overflow if it is very deep. Calling a function millions of levels deep may exceed the stack, which is often only a few megabytes.

For huge depths, prefer iteration.

Convert Deep Recursion To A Loop

If recursion depth grows with input size, switch to a loop. This avoids stacking thousands of frames.

The loop below sums 1 to a large n safely with constant memory.

#include <stdio.h>

int main(void) {
    long total = 0;
    for (int i = 1; i <= 1000000; i++)
        total += i;
    printf("%ld\n", total);
    return 0;
}

Reduce Depth With Divide And Conquer

Splitting work in half keeps depth small. Summing a range by halving makes the depth grow like log of the size instead of linearly.

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

Watch Large Local Arrays

Big local variables make each frame heavy, so the stack fills faster.

Avoid declaring large arrays inside a recursive function; pass pointers or use the heap instead.

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

Use An Accumulator

Passing a running total as an accumulator keeps each frame small and makes the recursion tail-shaped.

Some compilers can then reuse a single frame.

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

A Safety Checklist

Before trusting a recursive function, check:

1. Is there a base case?
2. Does every call move toward it?
3. Could the depth be huge for large input?

If depth can explode, use a loop instead.

Testing With Small Inputs

Always test recursion first with tiny inputs you can verify by hand.

If small cases work and the depth stays bounded, you can scale up with confidence.

Quick Check

Spot the safest fix.

Recap

Stack overflow happens when recursion goes too deep or never stops. Always provide a reachable base case, shrink the argument each call, keep frames light, and switch to iteration when depth can grow with input size.

Frequently asked questions

Is the “Avoiding Stack Overflow” lesson free?

Yes — the full text of “Avoiding Stack Overflow” is free to read here on the web, and the C Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the C Academy course, upgrade to CoddyKit PRO.

What will I learn in “Avoiding Stack Overflow”?

Keep recursion bounded. You practise C Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start C Academy?

No prior experience is required. C Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 4 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Avoiding Stack Overflow” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this C Academy lesson?

Yes. Every C Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to C Academy