Prefix recursion notation in c++ - c++

Question

I was looking for recursive solution for evaluating expression in Polish prefix notation, didn't find, but i found pseudo code for that and I wanted to translate it to the C++ but it is hard. I wrote BIG LETTERS where I don't know how to do it. Please correct me I am java guy and for me C++ is big mess, but can't help it.
int preEval(stack<string> stos){
string el = "";
if(stos.empty()){
return 0;
}else if(stos.top() IS VALUE){
string el = stos.top();
stos.pop();
return atoi(el.c_str());
}else if(stos.top() IS OPERATOR){
int x = preEval(stos);
int y = preEval(stos);
return x OPERATOR y;
}
return 0;
}
EDIT
When I have expression like / 10 5 Should stack suppose to have elements(from top) / 10 5, or 5 10 / ? Just asking because if I want it in / 10 5 I have to read string somehow backwards.

Answer 1

I think, a better solution would be to split the work into 2 stages: lexing and parsing.
At the lexing stage, you classify each token to see whether it's an operator (+, -, etc.) or a constant, or maybe a variable. Then you pack the parsed entity into a structure containing the type and additional information.
At the parse stage, which is presented by your code, you work not with strings, but with structures. Looking at the structure, you can easily find out its type. (It can be either a field inside the structure or a structure's type if you choose to build a hierarchy of structures derived from a common base.)
Actually, the logic should be the same in both Java and C++.

Answer 2

If you have functions like these:
#include <assert.h>
#include <errno.h>
#include <stdlib.h>
#include <iostream>
#include <stack>
#include <string>
using std::stack;
using std::string;
using std::cerr;
enum Operator {
operator_none,
operator_plus,
operator_minus
};
Operator tokenOperator(const string &token)
{
if (token=="+") return operator_plus;
if (token=="-") return operator_minus;
return operator_none;
}
int applyOperator(Operator op,int x,int y)
{
switch (op) {
case operator_plus: return x+y;
case operator_minus: return x-y;
case operator_none:
break;
}
assert(false);
return 0;
}
bool isValue(const string &token,int &output_value)
{
char *end = 0;
errno=0;
output_value = strtol(token.c_str(),&end,10);
if (errno!=0) return false;
return *end=='\0';
}
bool isOperator(const string &token,Operator &output_operator)
{
output_operator = tokenOperator(token);
return output_operator!=operator_none;
}
Then preEval can be implemented like this:
int preEval(stack<string> &stos)
{
if (stos.empty()) return 0;
string el = stos.top();
stos.pop();
int value = 0;
Operator op = operator_none;
if (isValue(el,value)) return value;
if (isOperator(el,op)) {
int x = preEval(stos);
int y = preEval(stos);
return applyOperator(op,x,y);
}
return 0;
}

Answer 3

#include <string>
#include <map>
using namespace std;
bool is_value(string s) {
return s.find_first_not_of("0123456789") == string::npos;
}
int do_add(int x, int y) {
return x + y;
}
int do_subtract(int x, int y) {
return x - y;
}
// etc.
typedef int (*binary_op)(int, int); // Give this function pointer type a nice name
map<string, binary_op> ops;
// Somewhere before the preEval() is ever called
ops["+"] = do_add;
ops["-"] = do_subtract; // etc.
binary_op lookup_op(string s) {
map<string, binary_op>::const_iterator it = ops.find(s);
if (it != ops.end()) {
return *it;
} else {
return NULL;
}
}
Now, instead of separately testing whether the token is an operator and later performing that operator, use a single function call to get a pointer to the operator function that needs to be called (if the token is an operator) or NULL otherwise. I.e.:
}else if(stos.top() IS OPERATOR){
int x = preEval(stos);
int y = preEval(stos);
return x OPERATOR y;
}
becomes
} else {
binary_op op = lookup_op(stos.top());
if (binary_op != NULL) {
stos.pop(); // This fixes the bug I mentioned in my top comment
int x = preEval(stos);
int y = preEval(stos);
return op(x, y);
} else {
syntax_error();
}
}