Вычислить значение выражения в обратной польской записи с использованием стека

// obr.cpp : Defines the entry point for the console application.
//
 
#include "stdafx.h"
#include <iostream>
#include <locale>
#include <string>
#include <math.h>
using namespace std;
 
struct Stack
{
    char data;
    Stack *next;
};
 
class StackNode
{
    private:
        Stack *Head;
 
    public:
        StackNode()
        {
            Head = NULL;
        }
 
        void push(char val)
        {
            Stack *Ptr = new Stack;
            Ptr -> data = val;
            
            if(Head == NULL)
            {
                Head = Ptr;
                Ptr -> next = NULL;
            }
            else
            {
                Stack *temp = Head; 
                while(temp -> next != NULL)
                    temp = temp -> next;
 
                temp -> next = Ptr;
                Ptr -> next = NULL;
            }
        }
 
        void pop()
        {       
            Stack *temp = Head, *temp1; 
            if(Head != NULL)
            {
                if(Head -> next == NULL)
                {
                    delete Head;
                    Head = NULL;
                }
                else
                {
                    while(temp -> next != NULL)
                    {
                        temp1 = temp;
                        temp = temp -> next;
                    }
 
                    delete temp;
                    temp = temp1 -> next = NULL;
                }
            }
        }
 
        bool isEmpty()
        {
            return Head == NULL;
        }
 
        int Prioretet(char value)
        {
            if(value == '^')
                return 4;
            else if(value == '*' || value == '/')
                return 3;
            else if(value == '+' || value == '-')
                return 2;
            else
                return 1;
        }
 
        char Verschina()
        {
            Stack *Ptr = Head;
            if(Head != NULL)
            {
                if(Ptr -> next == NULL)
                    return Ptr -> data;
                else
                {
                    while(Ptr ->next != NULL)
                        Ptr = Ptr -> next;
                    
                    return Ptr -> data; 
                }
            }
            else
                return NULL;
        }
 
        void Print()
        {
            Stack *Ptr = Head;
            if(Head == NULL)
                wcout << L"Стэк пуст!\n";
            else
            {
                while(Ptr != NULL)
                {
                    cout << Ptr -> data;
                    Ptr = Ptr -> next;
                }
            }
        }
 
};
 
int translationToNumber(char *number)
{
    int size = strlen(number) - 1;
 
    int chislo = 0;
    for(int i = 1, j = size; j >= 0; i *= 10, j--)
        chislo += (number[j] - '0') * i;
 
    return chislo;
}
 
int _tmain(int argc, _TCHAR* argv[])
{
    wcout.imbue(locale(".866"));
 
    StackNode stack;
    Stack *Ptr = NULL, *Ptr1 = NULL;
 
    const int size = 256;
    int size_f, j = 0, size_p = 0, size_i,
    resultat, chislo_l, chislo_r;
    
    char infix[size] = "", postfix[size] = "",
    value[size] = "", prom_str[size] = "",
    l_push[size] = "", R_push[size] = "";
 
    wcout << L"Введите выражение: ";
        cin.getline(infix, sizeof(infix), '\n');
 
    /*-------------------------Перевод в постфиксную нотацию----------------------------*/
    size_i = strlen(infix) + 1;
    for(int i = 0; i < size_i; i++)
    {
        if(infix[i] <= '9' && infix[i] >= '1')
            postfix[size_p++] = infix[i];
        else if(infix[i] == '(')
            stack.push(infix[i]);
        else if(infix[i] == ')')
        {
            while(stack.Verschina() != '(')
            {
                postfix[size_p++] = stack.Verschina();
                stack.pop();
            }
 
            stack.pop();
        }
        else if(infix[i] == '+' || infix[i] == '-' || infix[i] == '*' || infix[i] == '/' || infix[i] == '^')
        {
            postfix[size_p++] = ' ';
 
            if(stack.isEmpty())
                stack.push(infix[i]);
            else
            {
                if(stack.Prioretet(infix[i]) > stack.Prioretet(stack.Verschina()))
                    stack.push(infix[i]);
                else
                {
                    postfix[size_p--] = ' ';
                    while(!stack.isEmpty() && stack.Prioretet(stack.Verschina()) >= stack.Prioretet(infix[i]))
                    {
                        postfix[size_p++] = stack.Verschina();
                        stack.pop();
                    }
 
                    stack.push(infix[i]);
                    postfix[size_p++] = ' ';
                }
            }
        }
    }
 
    while(!stack.isEmpty())
    {
        postfix[size_p++] = stack.Verschina();
        stack.pop();
    }
 
    wcout << L"Результат в постфиксной записи: " << postfix << "\n";
    /*-----------------------------------Конец переводa---------------------------------*/
    /*-------------------------Вычисление в постфиксной нотации-------------------------*/
 
    size_f = strlen(postfix);
    for(int i = 0; i < size_f; i++)
    {
        if(postfix[i] <= '9' && postfix[i] >= '1' || postfix[i] == ' ')
            stack.push(postfix[i]);
        else if(postfix[i] == '+' || postfix[i] == '-' || postfix[i] == '*' || postfix[i] == '/' || postfix[i] == '^')
        {
            j = 0;
            while(stack.Verschina() != ' ' && stack.Verschina() != NULL)
            {
                l_push[j++] = stack.Verschina();
                stack.pop();
            }
 
            stack.pop();
            strrev(l_push);
            chislo_l = translationToNumber(l_push);
            memset(l_push, 0, 256);
 
            j = 0;
            while(stack.Verschina() != ' ' && stack.Verschina() != NULL)
            {
                R_push[j++] = stack.Verschina();
                stack.pop();
            }
            
            strrev(R_push);
            chislo_r = translationToNumber(R_push);
            memset(R_push, 0, 256);
 
            if(postfix[i] == '+')
                resultat = chislo_r + chislo_l;
            else if(postfix[i] == '-')
                resultat = chislo_r - chislo_l;
            else if(postfix[i] == '*')
                resultat = chislo_r * chislo_l;
            else if(postfix[i] == '/')
                resultat = chislo_r / chislo_l;
 
            j = 0;
            while(resultat >= 1)
            {
                value[j++] = ((resultat % 10) + '0');
                resultat = resultat / 10;
            }
 
            strrev(value);
 
            for(int s = 0; s < strlen(value); s++)
                stack.push(value[s]);
        }
    }
 
    wcout << L"Результат вычисления выражения в постфиксной нотации: ";
    stack.Print();
    /*--------------------------------Конец вычисления--------------------------------*/
 
    cout << "\n\n";
    return 0;
}

int _tmain()