Символ перехода на новую строку в калькуляторе Страуструпа

/*
Êàëüêóëÿòîð.
Îáùàÿ ãðàììàòèêà 
               Çàÿâëåíèå (statment)
                |                |
            îáúÿâëåíèå         ÂÛ×ÈÑËÅÍÈÅ
          (declaration)     (expression)
                                 |
                         ïåðâè÷íûå âûðàæåíèå 
                          ÷èñëà è âûðàæåíèÿ 
                             â ñêîáêàõ 
                             (primary)
                                 |
                        ìíîæèòåëè èëè äåëèòåëè
                               (term)
                                 |
                          ÑÓÌÌÀ È ÐÀÇÍÎÑÒÜ 
                            (EXPRESSION)            
                            
*/  
 
#include "std_lib_facilities.h"
#include "windows.h"
 
 
//_______________________________________________________
 
class Token {       // îñíîâíûå òîêåíû
public: 
    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 { // ïîòîê òîêåíîâ
private:
    bool full{false};
    Token buffer;
    bool full_2{false};
    Token buffer_2;
public:
    Token_stream() 
        :full(false), buffer(0), full_2 (false), buffer_2 (0) { }
 
    Token get();
    void putback (Token t) 
    { 
    if (full_2)  error ("buffer is full");
    if (full==true)  
        {
            buffer_2 = t; 
            full_2 = true;
        }
    if(full==false) {buffer=t; full=true;}  
    }
 
    void ignore(char c);
};
//_______________________________________________________
const char let = 'l';
const char con = 'c';
const char quit = 'q';
const char print = ';';
const char number = '8';
const char name = 'a';
const string declkey ="let";
const string sqrtkey = "sqrt";
const string powkey ="pow";
const string exitkey ="exit";
const string conkey ="const";
const char pown ='d';
const char sq='s';
//_______________________________________________________
 
Token Token_stream::get()   // Àíàëèçèðóåò âõîäíûå äàííû è ðàçáèâàåò èõ íà òîêåíû 
{
    if (full) { full=false; return buffer; }
    if (full_2) { full_2=false; return buffer_2; }
    char ch;
    cin >> ch;
    switch (ch) 
    {
    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.putback(ch);
        double val;
        cin >> val;
        return Token(number,val);
    case '#':
        return Token{let};  
    }
    default:
        if (ch=='/n') return Token{print};      // [COLOR="Red"]вот эта строка [/COLOR]
        if (isalpha(ch)) {
            string s;
            s += ch;
            while(cin.get(ch) && (isalpha(ch) || isdigit(ch)||ch=='_')) s+=ch;
            cin.putback(ch);
            if (s == sqrtkey) return Token {sq};
            if (s == exitkey) return Token {quit};
            if (s == declkey) return Token {let};
            if (s == powkey) return  Token {pown};
            if (s == conkey) return  Token {con};               
            return Token (name,s);
        }
        error("Bad token");
    }
}
//_______________________________________________________
void Token_stream::ignore(char c) // Íóæíà äëÿ ðàáîòû ôóíêöèè clean up mess èãíîðèò âñå ñèìâîëû ïîêà íå âñòðåòèò èñêîìûé 
{
    if (full && c==buffer.kind) {
        full = false;
        return;
    }
    full = false;
 
    char ch;
    while (cin>>ch)
        if (ch==c) return;
}
//_______________________________________________________
Token_stream ts;
//_______________________________________________________
double expression();
//_______________________________________________________
class Variable { // êëàññ äëÿ ðàáîòû ñ ïåðåìåííûìè è îïðåäåëåíèÿìè
    public:
        bool con;
        string name;
        double value;
        Variable(string n, double v, bool c) :name(n), value(v), con(c) { }
};
 
class Symbol_table {
    private:
        vector<Variable> names;
    public:
        bool is_declared(string s);
        double define_name(string name, double value, bool c);
        double get_value (string s);
        void set_value (string s, double d, bool c);
        double set_const();                     
};
//_______________________________________________________
bool Symbol_table::is_declared(string s)
{
    for (Variable& v : names)
        if (v.name == s) return true;
    return false;
}
//_______________________________________________________
double Symbol_table::define_name(string name, double value, bool c)
{
    if (is_declared(name)) error(name, " declared twice");
        names.push_back(Variable(name,value,c));
        return value;
}
//_______________________________________________________
double Symbol_table::get_value(string s)// âûäàåò çíà÷åíèå ïåðåìåííîé
{
    for (Variable& v : names)
        if (v.name == s) return v.value;
    error("get: undefined name ",s);
}
//_______________________________________________________
void Symbol_table::set_value(string s, double d, bool c) // îïðåäåëåíèå çíà÷åíèÿ ïåðåìåííîé
{
    for (Variable& v : names)
    {   
        if (v.name == s && v.con==false && c==false) 
        {   
            v.value = d;
            return;
        }
        if (v.name == s && v.con==false && c==true) 
        {   
            v.value = d;
            v.con = true;
            return;
        }
        if (v.name == s && v.con==true) error ("this variable is constanata ");     
    }   
    error("set: undefined name ",s);
    return;
}
//_______________________________________________________
 
double Symbol_table::set_const()
{
    Token t = ts.get();
    Token t2=ts.get();
    if (t.kind != name) error ("name expected in declaration");
    string name = t.name;
    if (is_declared(name)==true) 
    {
        if (t2.kind != '=') error("= missing in declaration of " ,name);
        double d = expression();
        bool c=true;
        set_value(name,d,c);
        return d;
    }
    else        
        if (t2.kind != '=') error("= missing in declaration of " ,name);
        double d = expression();
        bool c = true;
        define_name(name,d,c);
        return d;       
}
//_______________________________________________________
    double pow_n(double a, double b)
    {
        int z=b;
        if(z!=b) error( "is not integer");
        z=a;
        while(b>1)      
            {
                b--;
                z*=a;
            }
        return z;
    }
//_______________________________________________________
Symbol_table st;
//_______________________________________________________
double primary() // îïðåäåëÿåò ïåðâè÷íîå âûðàæåíèå ÷èñëî èëè èçíà÷åíèå â ñêîáêàõ 
{
    Token t = ts.get();
    switch (t.kind) {
    case '(':
    {   double d = expression();
        t = ts.get();
        if (t.kind != ')') error("')' expected");
        break;
    }
    case sq:
    {
        t = ts.get();
        if (t.kind != '(') error("'(' expected");
        double d = expression();
        if (d<0) error("sqrt -", d);
        d = sqrt(d);
        t = ts.get();
        if (t.kind != ')') error("')' expected");
        break;                  
    }
    case pown:
    {
        t = ts.get();
        if (t.kind != '(') error("'(' expected");
        t = ts.get();
        if (t.kind != number) error("number  expected");
        Token b=ts.get();
        if (b.kind != ',') error("',' expected");       
        b = ts.get();
        if (b.kind != number) error("number  expected");
        double d = pow_n(t.value, b.value);
        t = ts.get();
        if (t.kind != ')') error("')' expected");
        return d;       
        break;      
    }
    case '-':
        return - primary();
    case '+':
        return  primary();  
    case number:
        return t.value;
    case name:
        return st.get_value(t.name);
    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");
            left /= d;
            break;
        }
        default:
            ts.putback(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.putback(t);
            return left;
        }
    }
}
 
 
 
//_______________________________________________________
double assignment ()
    {
        Token t=ts.get();
        Token t2=ts.get();
        double d=0;
        bool c = false;
        switch (t2.kind){
            case '=':
                d=expression();
                st.set_value(t.name,d,c);               
                return d;
            default:
                ts.putback(t);
                ts.putback(t2);
                d=expression();
                return d;               
        }       
    }
//_______________________________________________________
double declaration() // èíèöèëèçàöèÿ è ïðèñâàèâàèâàíèå çíà÷åíèÿ
{   Token t = ts.get();
    if (t.kind != name) error ("name expected in declaration"); // name ýòî ñèìâîëüíàÿ êîíñòàíòà â Token t åå ïðîïèñûâàåò ô-íöèÿ get token   ïî êîíñòðóêòîðó  Token(char ch, string n)  :kind(ch), name(n) { }
    string name = t.name;
    if (st.is_declared(name)) error(name, " declared twice");
    Token t2 = ts.get();
    if (t2.kind != '=') error("= missing in declaration of " ,name);
    double d = expression();
    bool c = false;
    st.define_name(name,d,c);
    return d;
}
//_______________________________________________________
double statement() // çàÿâëåíèå 
{
    Token t = ts.get();
    switch(t.kind) {
    case con:
        return st.set_const();  
    case let:
        return declaration();
    case name:
        ts.putback(t);      
        return assignment();    
    default:
        ts.putback(t);
        return expression();
    }
}
//_______________________________________________________
 
void clean_up_mess()
{
    ts.ignore(print);
}
//_______________________________________________________
const string prompt = "> ";
const string result = "= ";
//_______________________________________________________
void calculate()
{
    while(true)
     try {
        cout << prompt;
        Token t = ts.get();
        while (t.kind == print) t=ts.get();
        if (t.kind == quit) return;
        ts.putback(t);
        cout << result << statement() << '\n';
    }
    catch(exception& e) {
        cerr << e.what() << '\n';
        clean_up_mess();
    }
}
//_______________________________________________________
int main()
 
 
    try {
        st.define_name("k",1000,true);
        calculate();
        keep_window_open();
        return 0;
    }
    catch (exception& e) {
        cerr << "exception: " << e.what() << endl;
        char c;
        keep_window_open("~~");
        return 1;
    }
    catch (...) {
        cerr << "exception\n";
        keep_window_open("~~");
        return 2;
    }

std::cout << "rigth slash: " << '/n' << std::endl;
std::cout << "left slash: " << '\n' << std::endl;