能否从Stack Overflow异常恢复执行？相关技术疑问

Let’s break down your questions one by one with practical C++ context:

1. Can you recover from a Stack Overflow exception and continue executing the next instruction? #

In standard C++, stack overflow is not a catchable exception—it’s classified as a fatal runtime error. When stack overflow occurs, the program’s call stack is already exhausted, meaning there’s no remaining stack space to even set up and execute an exception handler. Wrapping risky code in a try/catch block won’t help here; the runtime can’t safely jump to the catch handler because there’s no stack left to support the context switch.

Some platforms offer non-standard workarounds (like Windows’ structured exception handling or Linux signal handlers for SIGSEGV), but these are not portable. Even if you can catch the error, resuming normal execution is extremely dangerous (more on that later).

2. Can the provided infinite recursion code be fixed to avoid crash and continue? #

Looking at your code, the try/catch around causeStackOverflow() won’t work for two key reasons:

• Stack overflow does not throw a std::exception (or any standard exception type), so your catch block will never trigger.
• Even if it did, the stack is already too full to execute the catch handler’s code.

The program will crash before reaching the catch block, and there’s no standard C++ way to recover and resume the subsequent sum(1,2) call.

3. If a recovery method exists, should you use it? #

Absolutely not, even if you find a non-standard way to catch the error. Stack overflow leaves the program in an undefined state:

• The call stack is corrupted—functions may not have cleaned up local variables, return addresses could be invalid, and critical program state may be lost.
• Trying to continue execution can lead to unpredictable behavior: further crashes, data corruption, or even security vulnerabilities.

Instead of trying to recover from stack overflow, focus on preventing it in the first place.

4. Can you predict stack overflow in advance to avoid it? #

Yes, there are several reliable ways to mitigate stack overflow risk:

• Set recursion depth limits: For recursive functions, add a counter parameter to track how deep the recursion has gone. If it exceeds a safe threshold (determined by your system’s stack size), stop recursing and handle the case iteratively or return an error. Example:

  void safeRecursion(int depth) {
      if (depth > 1000) { // Arbitrary safe limit based on stack size
          std::cerr << "Recursion depth limit reached—aborting\n";
          return;
      }
      safeRecursion(depth + 1);
  }
  

• Track stack usage programmatically: On most systems, you can query the current stack pointer and compare it to the stack’s bounds. For example:

  • Linux: Use pthread_attr_getstacksize to get the stack size, and compare the current stack pointer (via __builtin_frame_address(0) or inline assembly) to the stack base.
  • Windows: Use GetCurrentThreadStackLimits to get the stack’s start and end addresses.

• Replace recursion with iteration: Convert recursive algorithms to use an explicit stack data structure (stored on the heap) instead of relying on the program’s call stack. This avoids stack overflow entirely since heap memory is typically much larger than stack memory.

• Static analysis: Use compiler warnings (like GCC’s -Wrecursion or Clang’s -Winline) or static analysis tools to detect obvious infinite recursion cases before runtime.

内容的提问来源于stack exchange，提问作者Stew