Ох уж эта книга бьярне

class Token {
public:
    char kind;        // what kind of token
    double value;     // for numbers: a value 
    Token(char ch)    // make a Token from a char
        :kind(ch), value(0) { }
    Token(char ch, double val)     // make a Token from a char and a double
        :kind(ch), value(val) { }
};
 
//------------------------------------------------------------------------------
 
class Token_stream {
public:
    Token_stream();
    Token get();
    void putback(Token t);
private:
    bool full;
    Token buffer;
};
 
Token_stream::Token_stream()
    :full(false), buffer(0) 
{
}
 
 
void Token_stream::putback(Token t) {
    if (full)
        perror("putback() into a full buffer");
    buffer = t;
    full = true;
}
 
 
Token get()    // read a token from cin
{
    if (full) {       // do we already have a Token ready?
                      // remove token from buffer
        full = false;
        return buffer;
    }
 
    char ch;
    cin >> ch;    // note that >> skips whitespace (space, newline, tab, etc.)
 
    switch (ch) {
        //not yet   case ';':    // for "print"
        //not yet   case 'q':    // for "quit"
    case '(': case ')': case '+': case '-': case '*': case '/':
        return Token(ch);        // let each character represent itself
    case '.':
    case '0': case '1': case '2': case '3': case '4':
    case '5': case '6': case '7': case '8': case '9':
    {
        cin.putback(ch);         // put digit back into the input stream
        double val;
        cin >> val;              // read a floating-point number
        return Token('8', val);   // let '8' represent "a number"
    }
    default:
        perror("Bad token");
    }
}
 
Token_stream ts;
 
double expression();
 
 
 
double primary() {
    Token t = get();
    switch (t.kind) {
    case '(':{
        double d = expression();
        t = ts.get();
        if (t.kind != ')') {
            perror("Must have ')'");
        }
        return d;
    }
    case '8':
        return t.value;
    default:
        perror("Need first expression!!!");
    }
}
 
double term() {
    double left = primary();
    Token t = ts.get();
    while (true) {
        switch (t.kind) {
        case '*':
            left *= primary();
            t = ts.get();
            break;
        case '/': {
            double d = primary();
            if (d == 0) {
                perror("Divided zero!!!");
            }
 
            left /= primary();
            t = ts.get();
            break;
        }
        default:
            ts.putback(t);
            return left;
        }
    }
 
}
 
double expression() {
    double left = term();
    Token t = ts.get();
    while (true) {
        switch (t.kind) {
        case '+':
            left += term();
            t = ts.get();
            break;
        case '-':
            left -= term();
            t = ts.get();
            break;
        default:
            ts.putback(t);
            return left;
        }
    }
 
}
 
 
 
int main() {
    try {
        while (cin) {
            cout << "= "<< expression() << '\n';
        }
        keep_window_open();
    }
    catch (exception& e) {
        cerr << e.what() << '\n';
        keep_window_open();
        return 1;
    }
    catch (...) {
        cerr << "exception\n";
        keep_window_open();
        return 2;
    }
}