在递归下降语法分析器中避免了递归算法中的stackoverflow

我参与了一个与解析器相关的项目，并使用递归下降解析器实现了它。然而，这个问题很容易导致堆栈溢出。处理这类问题的技巧是什么？

为了便于说明，这里有一个简单的数学表达式解析器，支持加法、减法、乘法和除法。分组圆括号是可以使用的，它们显然会触发递归。

这是完整的代码：

#include <string>
#include <list>
#include <iostream>
using namespace std;
struct term_t;
typedef list<term_t> prod_t;
typedef list<prod_t> expr_t;
struct term_t
{
    bool div;
    double value;
    expr_t expr;
};
double eval(const expr_t &expr);
double eval(const term_t &term)
{
    return !term.expr.empty() ? eval(term.expr) : term.value;
}
double eval(const prod_t &terms)
{
    double ret = 1;
    for (const auto &term : terms)
    {
        double x = eval(term);
        if (term.div)
            ret /= x;
        else
            ret *= x;
    }
    return ret;
}
double eval(const expr_t &expr)
{
    double ret = 0;
    for (const auto &prod : expr)
        ret += eval(prod);
    return ret;
}
class expression
{
public:
    expression(const char *expr) : p(expr)
    {
        prod();
        for (;;)
        {
            ws();
            if (!next('+') && *p != '-') // treat (a-b) as (a+-b)
                break;
            prod();
        }
    }
    operator const expr_t&() const
    {
        return expr;
    }
private:
    void term()
    {
        expr.back().resize(expr.back().size() + 1);
        term_t &t = expr.back().back();
        ws();
        if (next('('))
        {
            expression parser(p);  // recursion
            p = parser.p;
            t.expr.swap(parser.expr);
            ws();
            if (!next(')'))
                throw "expected ')'";
        }
        else
            num(t.value);
    }
    void num(double &f)
    {
        int n;
        if (sscanf(p, "%lf%n", &f, &n) < 1)
            throw "cannot parse number";
        p += n;
    }
    void prod()
    {
        expr.resize(expr.size() + 1);
        term();
        for (;;)
        {
            ws();
            if (!next('/') && !next('*'))
                break;
            term();
        }
    }
    void ws()
    {
        while (*p == ' ' || *p == 't')
            ++p;
    }
    bool next(char c)
    {
        if (*p != c)
            return false;
        ++p;
        return true;
    }
    const char *p;
    expr_t expr;
};
int main()
{
    string expr;
    while (getline(cin, expr))
        cout << "= " << eval(expression(expr.c_str())) << endl;
}

如果运行，您可以键入简单的数学表达式，如1+2*3+4*(5+6*7)，并将正确计算195。我还添加了简单的表达式求值，它还导致递归，导致堆栈溢出，甚至比解析更容易。无论如何，解析本身是简单而明显的，我如何在不对代码进行巨大更改的情况下重写它，并完全避免递归？在我的例子中，我使用类似于(((((1)))))的表达式来引起递归，如果我只有几百个圆括号，我会得到堆栈溢出。如果我使用调试器(在Visual Studio中(遍历递归树，如果只有三个函数：[term->]expression ctor->prod->term，并且从寄存器检查来看，这三个函数占用700-1000字节的堆栈空间。通过优化设置和稍微篡改代码，我可以减少它的占用，通过编译器设置，我可以增加堆栈空间，或者在这种情况下，我也可以使用Dijksta的调车场算法，但这不是问题的关键：我想知道如何重写它以避免递归，同时，如果可能的话，不需要完全重写解析代码。