Recursion and Memoization

Stack Overflow in Recursion

What causes a stack overflow error in recursive functions, and how can I prevent it?

Abstract art representing computer programming

A stack overflow error occurs when a program attempts to use more memory space than is available on the call stack. In the context of recursive functions, a stack overflow can happen when the recursion depth becomes too large, causing the stack to run out of memory.

Causes of stack overflow in recursive functions:

  1. Infinite recursion: If a recursive function does not have a proper base case or the base case is never reached, it will continue to call itself indefinitely, leading to a stack overflow.
  2. Excessive recursion depth: Even if a recursive function has a proper base case, if the input size is too large or the recursion depth is too deep, it can still cause a stack overflow.

Preventing stack overflow in recursive functions:

  1. Ensure a proper base case: Make sure your recursive function has a well-defined base case that terminates the recursion. The base case should be reachable for all valid inputs.
  2. Limit recursion depth: If the input size can be large, consider limiting the recursion depth. You can do this by introducing a parameter that tracks the depth and stops the recursion if it exceeds a certain threshold.
  3. Use tail recursion optimization: Some compilers can optimize tail-recursive functions to avoid stack overflow. A tail-recursive function is one where the recursive call is the last operation in the function.
  4. Consider an iterative solution: If the recursion depth is too large or the problem can be solved iteratively, consider converting the recursive solution to an iterative one to avoid stack overflow.

Here's an example of a recursive function that causes a stack overflow:

#include <iostream>

int infiniteRecursion(int n) {
  // No base case, infinite recursion
  return infiniteRecursion(n + 1);

int main() {
  int result = infiniteRecursion(0);

  // This line is never reached
  std::cout << "Result: " << result << "\n";

In this case, the infiniteRecursion function will keep calling itself indefinitely, causing a stack overflow error.

To fix this, we can introduce a base case and limit the recursion depth:

#include <iostream>

int limitedRecursion(int n, int depth) {
  if (depth >= 1000) {
    std::cout << "Recursion depth limit reached\n";
    return n;
  return limitedRecursion(n + 1, depth + 1);

int main() {
  int result = limitedRecursion(0, 0);
  std::cout << "Result: " << result << "\n";
Recursion depth limit reached
Result: 1000

In this modified version, the limitedRecursion function checks the recursion depth and stops the recursion if it exceeds 1000. This prevents the stack overflow error and allows the program to terminate gracefully.

Remember, stack overflow errors can be tricky to detect and debug, especially if the recursion depth is large. It's crucial to design your recursive functions carefully, ensure proper base cases, and consider the limitations of the call stack.

Answers to questions are automatically generated and may not have been reviewed.

A computer programmer
Part of the course:

Professional C++

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Free, unlimited access

This course includes:

  • 124 Lessons
  • 550+ Code Samples
  • 96% Positive Reviews
  • Regularly Updated
  • Help and FAQ
Free, Unlimited Access

Professional C++

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Screenshot from Warhammer: Total War
Screenshot from Tomb Raider
Screenshot from Jedi: Fallen Order
Contact|Privacy Policy|Terms of Use
Copyright © 2024 - All Rights Reserved