Буфер в пользовательском классе из стринг

#include<iostream>
#include<iomanip>
#include<fstream>
#include<sstream>
#include<cmath>
#include<cstdlib>
#include<string>
#include<list>
#include <forward_list>
#include<vector>
#include<unordered_map>
#include<algorithm>
#include <array>
#include <regex>
#include<random>
#include<stdexcept>
 
using namespace std;
 
inline void keep_window_open()
{
    cin.clear();
    cout << "Please enter a character to exit\n";
    char ch;
    cin >> ch;
    return;
}
 
inline void error(const string& s)
{
    throw runtime_error(s);
}
 
class Grammar {
public:
    char kind;        // what kind of token
    string Wd;     // for numbers: a value
    Grammar(char ch, string w)     // make a Token from a char and a double
        :kind(ch), Wd(w) { }
};
 
class Grammar_stream {
public:
    Grammar_stream();
    Grammar get();      // get a Token (get() is defined elsewhere)
    void putback(Grammar w);
private:
    bool full;        // is there a Token in the buffer?
    Grammar buffer;     // here is where we keep a Token put back using putback()
};
 
// The constructor just sets full to indicate that the buffer is empty:
Grammar_stream::Grammar_stream()
    :full(false), buffer(' ')    // no Token in buffer
{
}
 
// The putback() member function puts its argument back into the Token_stream's buffer:
void Grammar_stream::putback(Grammar w)
{
    if (full) error("putback() into a full buffer");
    buffer = w;       // copy t to buffer
    full = true;      // buffer is now full
}
 
//------------------------------------------------------------------------------
 
Grammar Grammar_stream::get()
{
    if (full) {       // do we already have a Token ready?
                    // remove token from buffer
        full = false;
        return buffer;
    }
 
    string s;
    cin >> s;    // note that >> skips whitespace (space, newline, tab, etc.)
    if (s == ".")
        return Grammar('q', s);
    vector<string> article = { "the", "a", "an" };
    for (int i = 0; i < article.size(); ++i)
    {
        if (s == article[i])
            return Grammar('a', s);
    }
    return Grammar(' ', s);
 
}
 
Grammar_stream gs;
///////////////////////////////////////////////////////////////////////////////////////
 
Grammar noun()
{
    Grammar word = gs.get;
    if (word.kind == ' ')
    {
        vector<string> noun = { "birds", "fish", "C++" };
        for (int i = 0; i < noun.size(); ++i)
            if (word.Wd == noun[i])
                return Grammar('n', word.Wd);
    }
    return word;
}
 
Grammar verd()
{
    Grammar word = noun();
    if (word.kind == ' ')
    {
        vector<string> verb = { "rules", "fly", "swim" };
        for (int i = 0; i < verb.size(); ++i)
            if (word.Wd == verb[i])
                return Grammar('v', word.Wd);
    }
    return word;
}
 
Grammar league()
{
    Grammar word = verd();
    if (word.kind == ' ')
    {
        vector<string> league = { "and", "or", "but" };
        for (int i = 0; i < league.size(); ++i)
            if (word.Wd == league[i])
                return Grammar('l', word.Wd);
    }
    error("Слово неизвестно");
}
 
//программа определяет корректность предложения относительно грамматики английского языка
int main()
try
{
    setlocale(LC_ALL, "Russian");
 
    cout << "Введите предложение заканчивающееся ' .'";
    vector<char> sentence;
    while (cin)
    {
        while (cin)
        {
            Grammar word_left = gs.get;     //берем из потока ввода слово для проверки конца предложения и смотрим его тип
            if (word_left.kind == 'q')
            {
                cout << "Конец предложения\n";      //конец ввода предложения
                keep_window_open();
                break;
            }
            else
            {
                gs.putback(word_left);      //ложим его назазад
            }
            Grammar word = league();        //определяем тип слова из потока ввода
            sentence.push_back(word.kind());    //записываем в вектор последовательность типов слов для проверки грамматики
        }
    }
    keep_window_open();
    return 0;
}
catch (exception& e) {
    cerr << "error: " << e.what() << '\n';
    keep_window_open();
    return 1;
}
catch (...) {
    cerr << "Oops: unknown exception!\n";
    keep_window_open();
    return 2;
}

#include<iostream>
#include<iomanip>
#include<fstream>
#include<sstream>
#include<cmath>
#include<cstdlib>
#include<string>
#include<list>
#include <forward_list>
#include<vector>
#include<unordered_map>
#include<algorithm>
#include <array>
#include <regex>
#include<random>
#include<stdexcept>
 
using namespace std;
 
//программа кулькулятор
inline void error(const string& s)
{
    throw runtime_error(s);
}
 
inline void keep_window_open()
{
    cin.clear();
    cout << "Please enter a character to exit\n";
    char ch;
    cin >> ch;
    return;
}
 
inline void keep_window_open(string s)
{
    if (s == "") return;
    cin.clear();
    cin.ignore(120, '\n');
    for (;;) {
        cout << "Please enter " << s << " to exit\n";
        string ss;
        while (cin >> ss && ss != s)
            cout << "Please enter " << s << " to exit\n";
        return;
    }
}
 
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();   // make a Token_stream that reads from cin
    Token get();      // get a Token (get() is defined elsewhere)
    void putback(Token t);    // put a Token back
private:
    bool full;        // is there a Token in the buffer?
    Token buffer;     // here is where we keep a Token put back using putback()
};
 
//------------------------------------------------------------------------------
 
// The constructor just sets full to indicate that the buffer is empty:
Token_stream::Token_stream()
    :full(false), buffer(0)    // no Token in buffer
{
}
 
//------------------------------------------------------------------------------
 
// The putback() member function puts its argument back into the Token_stream's buffer:
void Token_stream::putback(Token t)
{
    if (full) error("putback() into a full buffer");
    buffer = t;       // copy t to buffer
    full = true;      // buffer is now full
}
 
//------------------------------------------------------------------------------
 
Token Token_stream::get()
{
    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) {
    case '=':    // for "print"
    case 'x':    // for "quit"
    case '{': case '}':
    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 '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:
        error("Bad token");
    }
}
 
//------------------------------------------------------------------------------
 
Token_stream ts;        // provides get() and putback() 
 
//------------------------------------------------------------------------------
 
double expression();    // declaration so that primary() can call expression()
 
//------------------------------------------------------------------------------
 
//работает со скобками { }
Token hooks()
{
    Token t = ts.get();
    switch (t.kind) {
    case '{':    // handle '(' expression ')'
    {
        double d = expression();
        t = ts.get();
        if (t.kind != '}') error("'}' expected");
        return Token('8', d);
    }
    case '(': case ')':
        return t;
    case '8':            // we use '8' to represent a number
        return t;  // return the number's value
    default:
        error("hooks expected");
    }
}
 
// работает с числами и скобками ( )
double primary()
{
    Token t = hooks();
    switch (t.kind) {
    case '(':    // handle '(' expression ')'
    {
        double d = expression();
        t = ts.get();
        if (t.kind != ')') error("')' expected");
        return d;
    }
    case '8':            // we use '8' to represent a number
        return t.value;  // return the number's value
    default:
        error("primary expected");
    }
}
 
//------------------------------------------------------------------------------
 
// работает с *, /
double term()
{
    double left = primary();
    Token t = ts.get();        // get the next token from token stream
 
    while (true) {
        switch (t.kind) {
        case '*':
        {
            left *= primary();
            t = ts.get();
            break;
        }
        case '/':
        {
            double d = primary();
            if (d == 0) error("divide by zero");
            left /= d;
            t = ts.get();
            break;
        }
        default:
            ts.putback(t);     // put t back into the token stream
            return left;
        }
    }
}
 
//------------------------------------------------------------------------------
 
// работает с + и -
double expression()
{
    double left = term();      // read and evaluate a Term
    Token t = ts.get();        // get the next token from token stream
 
    while (true) {
        switch (t.kind) {
        case '+':
            left += term();    // evaluate Term and add
            t = ts.get();
            break;
        case '-':
            left -= term();    // evaluate Term and subtract
            t = ts.get();
            break;
        default:
            ts.putback(t);     // put t back into the token stream
            return left;       // finally: no more + or -: return the answer
        }
    }
}
 
//------------------------------------------------------------------------------
 
int main()
try
{
    setlocale(LC_ALL, "Russian");
    cout << "Добро пожаловать в программу-калькулятор!\n" <<
        "Вводите выражения с числами с плавающей точкой.\n\n" <<
        "Программа умеет работать со скобками и операциями +, -, *, /.\n" <<
        "Для получения результата введите '=' в конце выражения.\n\n";
    double val = 0;
    while (cin) {
        Token t = ts.get();
 
        if (t.kind == 'x') break; // 'q' for quit
        if (t.kind == '=')        // ';' for "print now"
            cout << "=" << val << '\n';
        else
            ts.putback(t);
        val = expression();
    }
    keep_window_open();
}
catch (exception& e) {
    cerr << "error: " << e.what() << '\n';
    keep_window_open();
    return 1;
}
catch (...) {
    cerr << "Oops: unknown exception!\n";
    keep_window_open();
    return 2;
}

sentence.push_back(word.kind)
gs.get()

buffer(' ', " ")