我尝试编写一个函数，它接受一个简单的算术方程，将其转换为解析树，并返回计算值。 由于某种原因，返回的值根本不正确。 （不是说它有帮助，而是用Python编码的相同函数可以正常工作）。 我已经重新检查了多次，但我无法找到问题所在。 我已经测试了BinaryTree类和build_parse_tree()函数，它们似乎可以正常工作。 我很确定这是eval_parse_tree()函数的问题。 请让我知道这个实现的问题是什么。

是的，我知道这个实现只适用于个位数，但这在这里应该不是问题。

#include <iostream>
#include <vector>
using namespace std;

class BinaryTree{
private:
    char root;
    BinaryTree * left = NULL;
    BinaryTree * right = NULL;
public:
    BinaryTree(char root_val){
        // constructor
        root = root_val;
    }
    void insert_right(char value){
        BinaryTree * new_node = new BinaryTree(value);
        if(right == NULL)
            right = new_node;
        else{
            new_node -> right = right;
            right = new_node;
        }
    }
    void insert_left(char value){
        BinaryTree * new_node = new BinaryTree(value);
        if(left == NULL)
            left = new_node;
        else{
            new_node -> left = left;
            left = new_node;
        }
    }
    BinaryTree * get_right(){
        return right;
    }
    BinaryTree * get_left(){
        return left;
    }
    char get_root(){
        return root;
    }
    void set_root(char value){
        root = value;
    }
};

bool is_operator(char token){
    string ops = "+-/*";
    for(unsigned long long int i = 0; i < ops.length(); i++)
        if(ops[i] == token)
            return true;
    return false;
}

BinaryTree * build_parse_tree(string expr){
    vector <BinaryTree *> stack;
    BinaryTree * tree = new BinaryTree(' ');
    stack.push_back(tree);
    for(long long unsigned int i = 0; i < expr.length(); i++){
        if(expr[i] == '('){
            tree -> insert_left(' ');
            stack.push_back(tree);
            tree = tree -> get_left();
        }
        else if(isdigit(expr[i])){
            tree -> set_root(expr[i]);
            tree = stack.back();
            stack.pop_back();
        }
        else if(is_operator(expr[i])){
            tree -> set_root(expr[i]);
            tree -> insert_right(' ');
            stack.push_back(tree);
            tree = tree -> get_right();
        }
        else{
            tree = stack.back();
            stack.pop_back();
        }
    }
    return tree;
}

int eval_parse_tree(BinaryTree * tree){
    //cout << "Root: " << tree -> get_root() << endl;
    char op;
    int left, right;
    BinaryTree * left_child = tree -> get_left();
    BinaryTree * right_child = tree -> get_right();
    if(left_child && right_child){
        op = tree -> get_root();
        left = eval_parse_tree(left_child);
        right = eval_parse_tree(right_child);
        switch(op){
            case '+': return (int)left + (int)right;
            case '-': return (int)left - (int)right;
            case '*': return (int)left * (int)right;
            case '/': return (int)left / (int)right;
        }
    }
    else
        return tree -> get_root();
}

int main(void){
    cout << eval_parse_tree(build_parse_tree("(5+(2*7))")) << endl; //returns 2803, instead of 19
}