Объектно-ориентированная программа для расчета арифметического выражения

#include <iostream.h>
 
int atoint(char *s)
{
    int r=0,i;
    char c;
 
    for (i=0;;i++)
    {
        c=*(s+i);
        if (c == 0) break;
        r=r*10+(int)(c-48);
    }
    return r;
}
 
int main(int argc, char* argv[])
{
    char *s="6789";
 
    cout << atoint(s) << endl;
 
    return 0;
}

#include <string>
#include <vector>
#include <iostream>
 
using namespace std;
 
class expr {
public:
    enum operation {
        add,
        subtract
    };
    void init(int val) {
        values.clear();
        operations.clear();
        values.push_back(val);
    }
    void append(operation op, int val) {
        operations.push_back(op);
        values.push_back(val);
    }
    int calc() const {
        if (values.empty())
            return 0;
        int sum = values[0];
        for (size_t i = 0; i < operations.size(); ++i) {
            operation op = operations[i];
            int v = values[i + 1];
            sum = (op == add) ? sum + v : sum - v;
        }
        return sum;
    }
private:
    vector<int> values;
    vector<operation> operations;
};
 
class parser {
public:
    parser(const char* s) : cur(s) {}
 
    bool parse(expr& e) {
        if (!*cur)
            return false;
        int val;
        if (!number(val))
            return false;
        e.init(val);
        expr::operation op;
        while (*cur) {
            if (!operation(op))
                return false;
            if (!number(val))
                return false;
            e.append(op, val);
            skip();
        }
        return true;
    }
private:
    void skip() {
        while (*cur == ' ')
            ++cur;
    }
    bool number(int& val) {
        skip();
        bool needCloseParen = false;
        if (*cur == '(') {
            ++cur;
            skip();
            needCloseParen = true;
        }
        bool negative = false;
        if (*cur == '+' || *cur == '-') {
            negative = (*cur == '-');
            ++cur;
            skip();
        }
        if (*cur < '0' && *cur > '9')
            return false;
        val = 0;
        while (*cur >= '0' && *cur <= '9') {
            val = 10*val + (*cur - '0');
            ++cur;
        }
        if (negative)
            val = -val;
        if (needCloseParen) {
            skip();
            if (*cur != ')')
                return false;
            ++cur;
        }
        return true;
    }
    bool operation(expr::operation& op) {
        skip();
        if (*cur == '+' || *cur == '-') {
            op = (*cur == '+') ? expr::add : expr::subtract;
            ++cur;
            return true;
        }
        return false;
    }
    const char* cur;
};
 
string binary(int val) {
    string s;
    int n = sizeof(int)*CHAR_BIT;
    while(n--) {
        char c = ((1 << n) & val) ? '1' : '0';
        if (c == '1' || !s.empty())
            s += c;
    }
    return s;
}
 
void calc(const string& s) {
    expr e;
    parser p(s.c_str());
    if (!p.parse(e)) {
        cout << "Expression \"" << s << "\" is not valid!" << endl;
    } else {
        int val = e.calc();
        cout << "Value of expression \"" << s << "\" is " << val
             << " = " << binary(val) << endl;
    }
}
 
int main() {
    calc("2 + 3");
    calc("2 + (-3) ");
    calc("1 + (-5) - 3 - (-2)");
}