Калькулятор для подсчёта комплексных чисел с++

#include <iostream>
#include <cstring>
 
using namespace std;
 
int main(int argc, char *argv[])
{
    char a[100]; //Исходная строка
    char b[100]; //Польская запись
    char stack[50];
    int n = 0;   //Позиция указателя в польской записи
    int p = 0;
 
    cout << "Vvedite Virazenie" << endl;
    cin >> a;
    int kol = strlen(a); //Определяем длинну выражения
 
    for (int i = 0; i<kol; i++)
    {
        if (a[i] == '(')                                   //Если открывающая скобка
        {
            p += 1;
            stack[p] = a[i];
        }
        else
            if (a[i] == '+' || a[i] == '-')                //Если плюс или минус
            {
                if (p == 0)
                {
                    p += 1;
                    stack[p] = a[i];
                }
                else
                    if (stack[p] == '(')
                    {
                        p += 1;
                        stack[p] = a[i];
                    }
                    else
                {
                    while (stack[p] == '+' || stack[p] == '-' || stack[p] == '*' || stack[p] == '/')
                    {
                        b[n] = stack[p];
                        p -= 1;
                    }
                }
            }
            else
                if (a[i] == '*' || a[i] == '/')            //Если умножить или равно
                {
                    if (p == 0)
                    {
                        p += 1;
                        stack[p] = a[i];
                    }
                    else
 
                        if (stack[p] == '+' || stack[p] == '-' || stack[p] == '(')
                        {
                            p += 1;
                            stack[p] = a[i];
                        }
                        else
 
                        while (stack[p] == '*' || stack[p] == '/')
                        {
                            b[n] = stack[p];
                            p -= 1;
                        }
                    }
                
                else
                    if (a[i] == ')')                       //Если закрывающая скобка
                    {
                        while (stack[p] != '(')
                        {
                            b[n] = stack[p];
                            n += 1;
                            p -= 1;
                        }
                        p -= 1;
                    }
                    else
                    {
                        b[n] = a[i];
                        n += 1;
                    }
 
    }
    
    while (p != 0) 
    {
        b[n] = stack[p];
        n += 1;
        p -= 1;
    }
    b[n] = '\0';
 
    cout << b << endl;
    int rez = 0;
    kol = strlen(b);
    p = 0;
    n = 0;
    int p2 = 1;
    float per[10];
    float stc[10];
 
    float r1 = 0;
    float r2 = 0;
 
        for (int i = 0; i < kol; i++)
        {
            if (b[i] != '+' && b[i] != '-' && b[i] != '/' && b[i] != '*')
            {
                p += 1;
                cout << "Vvedite peremennuju " << b[i] << endl;
                cin >> per[p];
            }
        }
 
        p = 0;
 
        for (int i = 0; i < kol; i++)
        {
            switch (b[i])
            {
            case '+':
            {
                r2 = stc[p];
                r1 = stc[p - 1];
                stc[p - 1] = r1 + r2;
                p -= 1;
                break;
            }
            case '-':
            {
                r2 = stc[p];
                r1 = stc[p - 1];
                stc[p - 1] = r1 - r2;
                p -= 1;
                break;
            }
            case '/':
            {
                r2 = stc[p];
                r1 = stc[p - 1];
                stc[p - 1] = r1/r2;
                p -= 1;
                break;
            }
            case '*':
            {
                r2 = stc[p];
                r1 = stc[p - 1];
                stc[p - 1] = r1*r2;
                p -= 1;
                break;
            }
            default:
                p += 1;
                stc[p] = per[p2];
                p2 += 1;
 
                break;
            }
 
        }
 
        cout << "Rezultat = " << stc[p];
    system("pause");
    return 0;
}

///////////////////////////////////////////////////////////////////////////////
//4.
///////////////////////////////////////////////////////////////////////////////
//Калькулятор комплексных чисел, на основе выражений в ПОЛИЗ
//(обратная польская запись), который выполняет операции :
//сложения,вычитания, умножения,деления. Т.е мы вводим выражение
//комплексного числа,оно переводится в ПОЛИЗ и потом выводит нам результат.
///////////////////////////////////////////////////////////////////////////////
#include <cctype>
#include <complex>
#include <deque>
#include <iostream>
#include <sstream>
#include <string>
///////////////////////////////////////////////////////////////////////////////
typedef std::string                     T_str;
typedef std::complex    < double    >   T_num;
///////////////////////////////////////////////////////////////////////////////
enum    T_op
{
    EMPTY_OP,
 
    ADD_OP,
    SUB_OP,
 
    MULT_OP,
    DIV_OP,
 
    LEFT_BR_OP,
    RIGHT_BR_OP
};
///////////////////////////////////////////////////////////////////////////////
struct  T_token
{
    //-------------------------------------------------------------------------
    T_num   num_val_    {};
    T_op    op_val_     {};
    bool    is_num_     {};
    //-------------------------------------------------------------------------
    T_token()   =   default;
    //-------------------------------------------------------------------------
    bool    is_num()
    {
        return  is_num_;
    }
    //-------------------------------------------------------------------------
    bool    is_op()
    {
        return  !is_num_;
    }
    //-------------------------------------------------------------------------
    T_op    op_val()
    {
        return  op_val_;
    }
    //-------------------------------------------------------------------------
    T_num   num_val()
    {
        return  num_val_;
    }
    //-------------------------------------------------------------------------
    void    set_num( T_num  num )
    {
        num_val_    =   num;
        is_num_     =   true;
    }
    //-------------------------------------------------------------------------
    bool    successfully_set_op( char   op_symb )
    {
        is_num_     =   false;
        bool    bool_res{ true };
 
        switch( op_symb )
        {
        case    '+'     :   op_val_     =   ADD_OP;         break;
        case    '-'     :   op_val_     =   SUB_OP;         break;
 
        case    '*'     :   op_val_     =   MULT_OP;        break;
        case    '/'     :   op_val_     =   DIV_OP;         break;
 
        case    '('     :   op_val_     =   LEFT_BR_OP;     break;
        case    ')'     :   op_val_     =   RIGHT_BR_OP;    break;
 
        default         :   bool_res    =   false;
        }//switch
 
        return  bool_res;
    }
    //-------------------------------------------------------------------------
    int     order()
    {
        switch( op_val_ )
        {
        case    LEFT_BR_OP      :   return  1;
        case    RIGHT_BR_OP     :   return  2;
 
        case    ADD_OP          :
        case    SUB_OP          :   return  3;
 
        case    MULT_OP         :
        case    DIV_OP          :   return  4;
        default                 :   return  0;
        }//switch
    }
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
typedef T_str                       T_expr;
typedef std::deque  < T_token   >   T_tokens;
///////////////////////////////////////////////////////////////////////////////
class   T_calculator
{
    //-------------------------------------------------------------------------
    const   T_str   INCORRECT_EXPR_MSG          { "expression is incorrect" };
    const   T_str   EMPTY_EXPR_MSG              { "expression is empty"     };
    const   T_str   UNBALANCED_BRACKETS_MSG     { "unbalanced brackets"     };
    //-------------------------------------------------------------------------
    T_str       res_;
    T_tokens    tokens_;
    T_tokens    res_tokens_;
    T_tokens    op_tokens_;
    //-------------------------------------------------------------------------
public:
    //-------------------------------------------------------------------------
    T_str   calc( T_expr    const   &   expr )
    {
        clear();
        T_expr  cur_expr{ expr };
 
        bool    bool_res    =       successfully_get_tokens     ( cur_expr )
                                &&  successfully_make_RPN       ()
                                &&  successfully_calculate      ();
 
        if  (
                    !bool_res
                &&  res_.empty()
            )
        {
            res_    =   INCORRECT_EXPR_MSG;
        }
 
        return  res_;
    }
    //-------------------------------------------------------------------------
private:
    //-------------------------------------------------------------------------
    void    clear()
    {
        res_            .clear();
        tokens_         .clear();
        res_tokens_     .clear();
        op_tokens_      .clear();
    }
    //-------------------------------------------------------------------------
    bool    successfully_get_tokens( T_expr     &   expr )
    {
        bool    bool_res{};
 
        while   (
                    trim_front      ( expr ),
                    !expr.empty     ()
                )
        {
            T_token     token;
 
            bool_res    =   successfully_get_token
                                (
                                    expr,
                                    token
                                );
 
            if( !bool_res )
            {
                return  bool_res;
            }
 
            tokens_.emplace_back( token );
        }//while
 
        bool_res    =   !tokens_.empty();
 
        if( !bool_res )
        {
            res_    =   EMPTY_EXPR_MSG;
        }
 
        return  bool_res;
    }
    //-------------------------------------------------------------------------
    void    trim_front( T_expr  &   expr )
    {
        while   (
                        !expr.empty()
 
                    &&  std::isspace
                            (
                                expr.front()
                            )
                )
        {
            expr.erase(0, 1);
        }
    }
    //-------------------------------------------------------------------------
    bool    successfully_get_token
        (
            T_expr      &   expr,
            T_token     &   token
        )
    {
        T_num   num;
        bool    bool_res    =   successfully_extract_num
                                    (
                                        expr,
                                        num
                                    );
 
        if  ( bool_res )
        {
            token.set_num( num );
        }
        else
        {
            bool_res    =   token.successfully_set_op
                                (
                                    expr.front()
                                );
 
            expr.erase(0, 1);
        }//else
 
        return  bool_res;
    }
    //-------------------------------------------------------------------------
    bool    successfully_extract_num
        (
            T_expr  &   expr,
            T_num   &   num
        )
    {
        std::istringstream  isstream( expr );
        bool                bool_res    =   isstream    >>  num;
 
        if( bool_res )
        {
            std::ostringstream  sout;
 
            sout    <<  isstream.rdbuf()
                    <<  std::endl;
 
            expr    =   sout.str();
        }//if
 
        return  bool_res;
    }
    //-------------------------------------------------------------------------
    bool    successfully_calculate()
    {
        bool        bool_res{};
        T_tokens    num_tokens;
 
        while   (
                    !res_tokens_.empty()
                )
        {
            if  (
                    res_tokens_.front().is_num()
                )
            {
                shift_from_front_to_back
                    (
                        res_tokens_,
                        num_tokens
                    );
            }
            else
            {
                bool_res    =       num_tokens.size()
                                >=  2;
 
                if( !bool_res )
                {
                    return  bool_res;
                }
 
                auto    R   =   num_tokens.back();
                num_tokens.pop_back();
 
                num_tokens.back()   =   execute_op
                                            (
                                                num_tokens.back     (),
                                                R,
                                                res_tokens_.front   ()
                                            );
 
                res_tokens_.pop_front();
            }
        }//while
 
        bool_res    =       num_tokens.size()
                        ==  1;
 
        if( bool_res )
        {
            std::ostringstream  osstream;
            osstream    <<  num_tokens.back().num_val();
            res_    =   osstream.str();
        }//if
 
        return  bool_res;
    }
    //-------------------------------------------------------------------------
    T_token     execute_op
        (
            T_token     L_token,
            T_token     R_token,
            T_token     op
        )
    {
        T_token     res;
        T_num       L   =   L_token.num_val();
        T_num       R   =   R_token.num_val();
 
        switch( op.op_val_ )
        {
        case    ADD_OP      :   res.set_num( L  +   R   );  break;
        case    SUB_OP      :   res.set_num( L  -   R   );  break;
        case    MULT_OP     :   res.set_num( L  *   R   );  break;
        case    DIV_OP      :   res.set_num( L  /   R   );  break;
        default             :   ;
        }//switch
 
        return  res;
    }
    //-------------------------------------------------------------------------
    bool    successfully_make_RPN()
    {
        bool    bool_res{};
 
        while   (
                    !tokens_.empty()
                )
        {
            if  (
                    tokens_.front().is_num()
                )
            {
                shift_from_front_to_back
                    (
                        tokens_,
                        res_tokens_
                    );
            }
            else
            {
                switch  (
                            tokens_.front().op_val()
                        )
                {
                case    LEFT_BR_OP  :
                    shift_from_front_to_back
                        (
                            tokens_,
                            op_tokens_
                        );
 
                    bool_res    =   !tokens_.empty();
 
                    if( !bool_res )
                    {
                        res_    =   UNBALANCED_BRACKETS_MSG;
                        return  bool_res;
                    }
 
                    bool_res    =   tokens_.front().op_val ()  !=  RIGHT_BR_OP;
 
                    if( !bool_res )
                    {
                        return  bool_res;
                    }
                    break;
 
                case    RIGHT_BR_OP :
                    bool_res    =   successfully_process_right_bracket();
 
                    if( !bool_res )
                    {
                        res_    =   UNBALANCED_BRACKETS_MSG;
                        return  bool_res;
                    }
                    break;
 
                default     :
                    process_op();
                }//switch
            }
        }//while
 
        while   (
                        !op_tokens_  .empty  ()
                    &&  op_tokens_   .back   ().op_val()    !=  LEFT_BR_OP//-//
                )
        {
            shift_from_back_to_back
                (
                    op_tokens_,
                    res_tokens_
                );
        }
 
        bool_res    =   op_tokens_.empty();
 
        if( !bool_res )
        {
            res_    =   UNBALANCED_BRACKETS_MSG;
        }
 
        return  bool_res;
    }
    //-------------------------------------------------------------------------
    void    shift_from_front_to_back
        (
            T_tokens    &   from,
            T_tokens    &   to
        )
    {
        to.emplace_back
            (
                from.front()
            );
 
        from.pop_front();
    }
    //-------------------------------------------------------------------------
    void    shift_from_back_to_back
        (
            T_tokens    &   from,
            T_tokens    &   to
        )
    {
        to.emplace_back
            (
                from.back()
            );
 
        from.pop_back();
    }
    //-------------------------------------------------------------------------
    bool    successfully_process_right_bracket()
    {
        while   (
                        !op_tokens_     .empty  ()
                    &&  op_tokens_      .back   ().op_val()     !=  LEFT_BR_OP
                )
        {
            shift_from_back_to_back
                (
                    op_tokens_,
                    res_tokens_
                );
        }//while
 
        bool    bool_res    =   !op_tokens_.empty();
 
        if( bool_res )
        {
            op_tokens_  .pop_back   ();
            tokens_     .pop_front  ();
        }
 
        return  bool_res;
    }
    //-------------------------------------------------------------------------
    void    process_op()
    {
        while   (
                        !op_tokens_.empty()
 
                    &&      op_tokens_  .back   ().order()
                        >=  tokens_     .front  ().order()
                )
        {
            shift_from_back_to_back
                (
                    op_tokens_,
                    res_tokens_
                );
        }//while
 
        shift_from_front_to_back
            (
                tokens_,
                op_tokens_
            );
    }
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////

int     main()
{
    std::ios::sync_with_stdio( false );
    T_calculator    calculator;
 
    for(;;)
    {
        std::cout   <<  "Enter arithm expr with complex numbers in form (1,2):"
                    <<  std::endl
                    <<  "-> ";
 
        T_expr  expr;
        getline     ( std::cin,  expr );
 
        std::cout   <<  calculator.calc( expr )
                    <<  std::endl
                    <<  std::endl
                    <<  std::endl;
    }//for
}