如何在 C++ 中处理或避免堆栈溢出

How to handle or avoid a stack overflow in C++(如何在 C++ 中处理或避免堆栈溢出)

问题描述

在 C++ 中，堆栈溢出通常会导致程序不可恢复的崩溃.对于需要真正健壮的程序，这是一种不可接受的行为，特别是因为堆栈大小是有限的.关于如何处理问题的几个问题.

In C++ a stack overflow usually leads to an unrecoverable crash of the program. For programs that need to be really robust, this is an unacceptable behaviour, particularly because stack size is limited. A few questions about how to handle the problem.

1. 有没有办法通过通用技术来防止堆栈溢出.(一种可扩展、强大的解决方案，包括处理消耗大量堆栈的外部库等)

1. Is there a way to prevent stack overflow by a general technique. (A scalable, robust solution, that includes dealing with external libraries eating a lot of stack, etc.)

如果发生堆栈溢出，有没有办法处理它们?最好，堆栈会展开，直到有处理程序来处理这种问题.

Is there a way to handle stack overflows in case they occur? Preferably, the stack gets unwound until there's a handler to deal with that kinda issue.

有些语言的线程具有可扩展的堆栈.类似的东西在 C++ 中可能吗?

There are languages out there, that have threads with expandable stacks. Is something like that possible in C++?

如果对 C++ 行为的解决方案有任何其他有用的意见，我们将不胜感激.

Any other helpful comments on the solution of the C++ behaviour would be appreciated.

推荐答案

处理堆栈溢出不是正确的解决方案，相反，您必须确保您的程序不会溢出堆栈.

Handling a stack overflow is not the right solution, instead, you must ensure that your program does not overflow the stack.

不要在堆栈上分配大变量(其中大"取决于程序).确保任何递归算法在已知最大深度后终止.如果递归算法可能会递归未知次数或大量次数，要么自己管理递归(通过维护自己的动态分配的堆栈)，要么将递归算法转换为等效的迭代算法

Do not allocate large variables on the stack (where what is "large" depends on the program). Ensure that any recursive algorithm terminates after a known maximum depth. If a recursive algorithm may recurse an unknown number of times or a large number of times, either manage the recursion yourself (by maintaining your own dynamically allocated stack) or transform the recursive algorithm into an equivalent iterative algorithm

必须真正健壮"的程序不会使用吃掉大量堆栈"的第三方或外部库.

A program that must be "really robust" will not use third-party or external libraries that "eat a lot of stack."

请注意，某些平台会在发生堆栈溢出时通知程序并允许程序处理错误.例如，在 Windows 上，会引发异常.此异常不是 C++ 异常，但它是异步异常.而 C++ 异常只能由 throw 语句引发，而异步异常可能在程序执行期间的任何时间引发.不过这是意料之中的，因为堆栈溢出随时可能发生:任何函数调用或堆栈分配都可能溢出堆栈.

Note that some platforms do notify a program when a stack overflow occurs and allow the program to handle the error. On Windows, for example, an exception is thrown. This exception is not a C++ exception, though, it is an asynchronous exception. Whereas a C++ exception can only be thrown by a throw statement, an asynchronous exception may be thrown at any time during the execution of a program. This is expected, though, because a stack overflow can occur at any time: any function call or stack allocation may overflow the stack.

问题是堆栈溢出可能导致异步异常被抛出，即使是从不期望抛出任何异常的代码(例如，从标记为 noexcept 或 throw() 在 C++ 中).因此，即使您确实以某种方式处理了此异常，您也无法知道您的程序处于安全状态.因此，处理异步异常的最好方法是根本不处理它^(*).如果抛出一个，则意味着程序包含错误.

The problem is that a stack overflow may cause an asynchronous exception to be thrown even from code that is not expected to throw any exceptions (e.g., from functions marked noexcept or throw() in C++). So, even if you do handle this exception somehow, you have no way of knowing that your program is in a safe state. Therefore, the best way to handle an asynchronous exception is not to handle it at all^(*). If one is thrown, it means the program contains a bug.

其他平台可能有类似的方法来处理"堆栈溢出错误，但任何此类方法都可能遇到相同的问题:预期不会导致错误的代码可能会导致错误.

Other platforms may have similar methods for "handling" a stack overflow error, but any such methods are likely to suffer from the same problem: code that is expected not to cause an error may cause an error.

^{(*) 有一些非常罕见的例外情况.}

这篇关于如何在 C++ 中处理或避免堆栈溢出的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持编程学习网！