Question

我正在为类创建一个解析器。用户必须在每个元素之间用空格输入等式。然后将每个元素读入其自己的索引中的相同数组中。我一直在堆栈溢出。我认为这是因为只有myCalculus函数的最后一次调用实际上才会关闭。但是，如果是这种情况，我不知道如何组织代码来避免这种情况。提前感谢您的帮助。

import java.util.Scanner;

public class InterpreterFour{
    public static void main(String []args){
    //read in the values as a string
    Scanner scan = new Scanner(System.in);
    String expressions = scan.nextLine();
    //save each token into the array
    String[] token = expressions.split("\\s+");

    int solved = 0;
    int o = 0;
    //call myCalculus function which will call the other functions
    System.out.println(myCalculus(token, 0, solved));
    }

    public static int myCalculus(String[] token, int o, int solved){
        while(o < token.length-1){
            if(token[o].equals("*")){
                multiply(token, o, solved);
            }
            else if(token[o].equals("+")){
                add(token, o, solved);
            }
            else if(token[o].equals("<")){
                compare(token, o, solved);
            }
            else if(token[o].equals("<=")){
                compare(token, o, solved);
            }
            else if(token[o].equals(">")){
                compare(token, o, solved);
            }
            else if(token[o].equals("<=")){
                compare(token, o, solved);
            }
            else if(token[o].equals("(")){
                myCalculus(token, o++, solved);
            }
            else{
                myCalculus(token, o++, solved);
            }
        }
        return solved;
    }

    public static void add(String[] token, int o, int solved){
        if(token[o++].matches("[-+]?\\d*\\.?\\d+")){
            solved = solved + Integer.parseInt(token[o--]) + Integer.parseInt(token[o++]);
            myCalculus(token, o++, solved);
        }
        else{
            myCalculus(token, o++, solved);
        }
    }

    public static void multiply(String[] token, int o, int solved){
        if(token[o++].matches("[-+]?\\d*\\.?\\d+")){
            solved = solved + Integer.parseInt(token[o--]) * Integer.parseInt(token[o++]);
            myCalculus(token, o++, solved);
        }
        else{
            myCalculus(token, o++, solved);
        }
    }

    public static void compare(String[] token, int o, int solved){
        if(token[o++].matches("[-+]?\\d*\\.?\\d+")){
            if(token[o].equals("<")){
                solved = solved + ((Integer.parseInt(token[o--]) < Integer.parseInt(token[o++])) ? 1 : 0);
            }
            else if(token[o].equals(">")){
                solved = solved + ((Integer.parseInt(token[o--]) > Integer.parseInt(token[o++])) ? 1 : 0);
            }
            else if(token[o].equals("<=")){
                solved = solved + ((Integer.parseInt(token[o--]) <= Integer.parseInt(token[o++])) ? 1 : 0);
            }
            else{
                solved = solved + ((Integer.parseInt(token[o--]) >= Integer.parseInt(token[o++])) ? 1 : 0);
            }
            myCalculus(token, o++, solved);
        }
        else{
            myCalculus(token, o++, solved);
        }
    }
}

Answer 1

Java中的参数是按值传递的，而不是通过引用传递的。

您的所有方法都不会返回值。您似乎期望solved将包含最终值，但它不会，因为它是按值传递的。

出于同样的原因，实际上并不需要所有++运算符。你应该将o + 1传递给较低级别。它不会影响递归上层的“o”变量！

最后，myCalculus方法中的while循环没有意义，因为你在其他方法中进行递归。因此，while会导致计算错误。

另请注意，您对括号的处理可能是错误的。你没有在任何地方处理一个结束括号，这可能也会导致错误的计算。

Answer 2

我认为您需要更改递归调用以使用++o而不是o++：

myCalculus(token, ++o, solved);

您的当前代码只会在调用o后递增myCalculus，因此，只要您遇到括号，您的代码就会进入无限循环。

如何修复自制解析器中的堆栈溢出？

2 个答案: