Как считать символ два раза

char ch = ' ';
cin.get(ch);

cin>>ch;

cin.get(ch);
if(isspace(ch)) return ';';
cin.putback(ch);
cin>>ch;

/*
    calculator08buggy.cpp
 
    Helpful comments removed.
 
    We have inserted 3 bugs that the compiler will catch and 3 that it won't.
*/
 
#include "std_lib_facilities.h"
bool check = false;
struct Token {
    char kind;
    double value;
    string name;
    Token(char ch) :kind(ch), value(0) { }
    Token(char ch, double val) :kind(ch), value(val) { }
    Token(char ch, string n) :kind(ch), name(n) {} // Конструктор для переменных
};
 
class Token_stream {// Поток лексем
    bool full; // Есть лексема?
    Token buffer; // Сдесь хранится лексема,которая возвращается назад с помощью функции putback();
public:
    Token_stream() // Конструктор считывающий данные из потока cin
    :full(0), buffer(0) { }
 
    Token get(); // Считываем лексему
    void unget(Token t) { buffer=t; full=true; }
 
    void ignore(char c);
};
const char help = 'H';
const string ex = "exit"; // Exit
const char constc = 'C';
const char powc = 'P';
const char let = 'L';
const char quit = 'q';// Token variable
const char print = ';'; 
const char number = '8'; // Value
const char name = 'a'; // Name of variable
const char sqrc = 'S'; // Token sqrt()
const string consts = "const";
const string declkey = "#"; //Variable
const string sqrs = "sqrt"; // Function square root;
const string pows = "pow";
struct Variable {
    string name;
    double value;
    bool constant;
    Variable(string n, double v) :name(n), value(v), constant(false) { }
    Variable(double v, string n) :value(v), name(n), constant(true) { }
};
vector<Variable> names; //Хранение объектов класса 
Token Token_stream::get()
{
    if (full) { full=false; return buffer; }
    char ch = ' ';
    cin >> ch;
    switch (ch) {
    case 'H':
    case ',':
    case '(':
    case ')':
    case '+':
    case '-':
    case '*':
    case '/':
    case '%':
    case ';':
    case '=':
        return Token(ch);
    case '.':
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
    {   
        cin.unget();
        double val;
        cin >> val;
        return Token(number,val);
    }
    default:
            
        if (isalpha(ch) || ch == '#') {
            string s;
            s += ch;
            // Считывает символ в переменную ch и проверяет, цифра это , или символ
            while(cin.get(ch) && (isalpha(ch) || isdigit(ch)) || ch == '_') s+=ch;
            cin.putback(ch);
            if (s == consts) {check = true;return Token(constc);}
            if (s == pows) return  Token(powc);
            if (s == sqrs) return Token(sqrc);
            if (s == declkey) return Token(let);    
            if (s == ex) return Token(quit);
            return Token(name,s);
        }
        error("Bad Token");
    }
}
 
void Token_stream::ignore(char c)
{ // Символ обозначает разновидность лексем
    // Сначала проверяем буфер
    if (full && c==buffer.kind) {
        full = false;
        return;
    }
    full = false;
    // Теперь проверяем входне данные
 
    char ch = 0;
    while (cin>>ch)
        if (ch==c) return;
}
 
 
 
double get_value(string s)//Ищет строку name и возвращает её value
{ // Возвращает значение переменной с именем s
    for (int i = 0; i<names.size(); ++i)
        if (names[i].name == s) return names[i].value;
    error("get: undefined name ",s);
}
 
void set_value(string s, double d)
{ // Присваевает объекту класса Variable с именем s значение d
    for (int i = 0; i<=names.size(); ++i)
        if (names[i].name == s) {
            names[i].value = d;
            return;
        }
    error("set: undefined name ",s);
}
 
bool is_declared(string s)
{ // Есть ли переменная var в векторе var_table?
    for (int i = 0; i<names.size(); ++i)
        if (names[i].name == s) return true;
    return false;
}
 
double define_name(string var,double val)
{ // Добавляем пару (var,val) в вектор names
    if(check == true) 
        names.push_back(Variable(val,var));
    else
    {
        names.push_back(Variable(var,val));
    }
    check = false;
    return val;
}
 
bool chek_const(string s)
{
    for(int i = 0; i<names.size(); ++i)
        if(names[i].name == s)
            if(names[i].constant == true)
                return true;
    return false;
}
 
Token_stream ts;
 
double expression();
 
double primary()
{
    Token t = ts.get();
    switch (t.kind) {
    case '(':
    {   double d = expression();
        t = ts.get();
        if (t.kind != ')') error("'(' expected");
    }
    
    case '-':
        return - primary();
    case number:
        return t.value;
    case name:
        return get_value(t.name);
    /*case sqrc: return t.value;*/
    default:
        error("primary expected");
    }
}
 
double term()
{
    double left = primary();
    while(true) {
        Token t = ts.get();
        switch(t.kind) {
        case '*':
            left *= primary();
            break;
        case '/':
        {   double d = primary();
            if (d == 0) error("divide by zero");
            if (left == 0 && d < 0) {left = 0; break;} 
            left /= d;
            break;
        }
        default:
            ts.unget(t);
            return left;
        }
    }
}
 
double expression()
{
    double left = term();
    while(true) {
        Token t = ts.get();
        switch(t.kind) {
        case '+':
            left += term();
            break;
        case '-':
            left -= term();
            break;
        default:
            ts.unget(t);
            return left;
        }
    }
}
 
double declaration()
{ // предпологается что мы можем выделить ключевое символ "#"
  // обработка name = expression
  // объявляется переменная с именем "name" с начальным значением,
  // заданным выражением 
    Token t = ts.get();
    if (t.kind != name) error ("name expected in declaration", t.name);
    string var_name = t.name;
    if (chek_const(var_name)) error("Attempt to change the constant " ,var_name);
    if (is_declared(var_name)) cout << "Variable has changed" << endl;
    Token t2 = ts.get();
    if (t2.kind != '=') error("= missing in declaration of " ,var_name);
    double d = expression();
    define_name(var_name,d);
    return d;
}
 
double square()
{
    Token t = ts.get();
    if(t.kind != '(') error ("'(' expexted");
    double b = expression();
    Token t2 = ts.get();
    if(t2.kind != ')') error ("')' expexted");
    if(b < 0) error("Error: square rood < 0");
    b = sqrt(b);
    
    return b;
}
double fpow()
{   
    double w = 0;
    Token t = ts.get();
    if(t.kind != '(') error ("'(' expexted");
    double c = expression();
    Token t2 = ts.get();
    if(t2.kind!= ',') error ("',' expexted");
    double c2 = expression();
    int check = c2;
    if(c2!=check) error(" Value mast be integer");
    w = c;
    Token t3 = ts.get();
    if(t3.kind != ')') error ("')') expexted");
    for(int i = 1; i<c2; i++)c = w*c;
    return c;
}
double statement()
{
    Token t = ts.get();
    switch(t.kind) {
    case powc:
        return fpow();
    case sqrc:
        return square();
    case let: case constc:
        return declaration();
    default:
        ts.unget(t);
        return expression();
    }
}
 
void clean_up_mess()
{
    ts.ignore(print);
}
 
const string prompt = "> ";
const string result = "= ";
 
void helps()
{
    system("cls");
    cout << "ПОДЗКАЗКА";
}
void calculate()
{
    while(true) try {
        cout << prompt;
        Token t = ts.get();
        while (t.kind == print) t=ts.get();// Игнорируем "печать"
        if (t.kind == quit) return;// Выход
        if(t.kind == help) helps();
        else{
        ts.unget(t);
        cout << result << statement() << endl;}
    }
    catch(exception& e) {
        cerr << e.what() << endl; // Выводим сообщение об ошибке
        clean_up_mess();
        
    }
    catch (...) {
        cerr << "exception\n";
        clean_up_mess();
        
    }
}
int main()
 
    try {
        setlocale(LC_ALL,"Rus");
        define_name("pi",3.1415926535);
        define_name("e", 2.7182818284);
        define_name("k", 1000);
        calculate();
        keep_window_open();
        return 0;
        }
    
    catch (exception& e) {
        cerr << e.what() << e.what() << endl;
        keep_window_open("~~");
        /*char c;
        while (cin >>c&& c!=';') ;*/
        return 1;
    }
    catch (...) {
        cerr << "exception\n";
        char c;
        while (cin>>c && c!=';');
        return 2;
    }

Token Token_stream::get()
{
    if (full) { full=false; return buffer; }
    char ch = ' ';
    char chc = ' ';
     chc = cin.peek();
    if(isspace(chc)) return Token(print);
    cin>>ch;
    switch (ch) {
    case 'H':
    case ',':
    case '(':
  //********

char ch = ' ';
    
    cin.get(ch);
    while(ch == ' ')
    cin.get(ch);
    if(isspace(ch)) return Token(print);
    switch (ch) {

while(ch == ' ')
    cin.get(ch);