Задачи для тренировки и лучшего понимания

#include <iostream>
#include <string>
#include <conio.h>
int main()
{
    int sizee=0;
    std::string s=" a bc def ghik ";
    for(int j=0;j<s.length();j++)
        if(s[j]==' ')
            sizee++;
    char c[sizee-1][10];
    int k=0;
    int isfree=0;
    for(int i=0;i<s.length();i++)
    {
        if(s[i]==' ')
        {
            k=i+1;
            std::cout<<s[k];
            while(s[k]!=' ')
            {    
                c[isfree][k+1-i]=s[k];
                k++;
            }
            isfree++;
        }
    }
    for(int l;l<sizee-1;l++)
        std::cout<<c[l]<<"\n";
    getch();
    return 0;
}

const std::string Addition       = "+";
const std::string Substraction   = "-";
const std::string Multiplication = "*";
const std::string Division       = "/";
const std::string LeftBracket    = "(";
const std::string RightBracket   = ")";

std::map<std::string, int> priority;
priority[Addition] = 1;
priority[Substraction] = 1;

int code = 0;                /* приоритет */
std::string word = Addition; /* или любое другое ключевое слово */
std::map<std::string, int>::iterator it;
 
if((it = priority.find(word)) != priority.end())
   code = it->second;

int getPriority(const std::string& lexeme)
{
    if(lexeme == "*" || lexeme == "/") return 3;
    if(lexeme == "+" || lexeme == "-") return 2;
    if(lexeme == "(") return 1;
 
    return 0; 
}

#include <iostream>
#include <iterator>
 
#include <vector>
#include <string>
#include <sstream>
#include <algorithm>
 
#include <stack>
#include <map>
 
std::vector<std::string> InitialiseKeywords()
{
   std::vector<std::string> Keywords;
 
   Keywords.push_back("+");
   Keywords.push_back("-");
   Keywords.push_back("*");
   Keywords.push_back("/");
 
   return Keywords;
}
 
std::vector<std::string> DivideExpressionOnTokens(const std::string &line)
{
   std::stringstream ss(line);
   std::vector<std::string> res;
 
   std::copy(std::istream_iterator<std::string>(ss), std::istream_iterator<std::string>(), std::back_inserter(res));
   
   return res;
}
 
std::map<std::string, int> InitialisePriorityTable()
{
   std::map<std::string, int> priority;
 
   priority["+"] = 1;
   priority["-"] = 1;
   priority["*"] = 2;
   priority["/"] = 2;
   priority["("] = 3;
   priority[")"] = 4;
 
   return priority;
}
 
std::vector<std::string> ConvertInfixToPostfixNotation(const std::vector<std::string> &Expression)
{
   int ActionCodesMatrix[5][4] = {
      { 0, 0, 0, 0 },
      { 1, 2, 2, 1 },
      { 1, 1, 2, 1 },
      { 1, 1, 1, 1 },
      { 4, 2, 2, 3 }
   };
 
   std::vector<std::string> OutTokens;
 
   std::map<std::string, int> Priorities = InitialisePriorityTable();
   std::stack<std::string> TokenStack;
 
   for(std::vector<std::string>::size_type i = 0; i < Expression.size(); ++i)  
   {
      // Set Priority Code
      int ExpressionCode = 0;
      int TokenStackCode = 0;
      std::map<std::string, int>::iterator it;
 
      if((it = Priorities.find(Expression[i])) != Priorities.end())
         ExpressionCode = it->second;
      if(TokenStack.empty() != true && (it = Priorities.find(TokenStack.top())) != Priorities.end())
         TokenStackCode = it->second;
 
      // Set Action Code
      int ActionCode = ActionCodesMatrix[ExpressionCode][TokenStackCode];
 
      // Action
      if(ActionCode == 0)
      {
         OutTokens.push_back(Expression[i]);
      }
 
      else if(ActionCode == 1)
      {
         TokenStack.push(Expression[i]);
      }
 
      else if(ActionCode == 2)
      {
         OutTokens.push_back(TokenStack.top());
         TokenStack.pop();
 
         --i;
      }
 
      else if(ActionCode == 3)
      {
         TokenStack.pop();
      }
 
      else
      {
         // TODO Error
      }
   }
 
   // Pop Stack
   while(TokenStack.empty() != true)
   {
      if(TokenStack.top() != "(" && TokenStack.top() != ")")
         OutTokens.push_back(TokenStack.top());
 
      TokenStack.pop();
   }
 
   return OutTokens;
}
 
double CalculatePostfixExpression(const std::vector<std::string> &PostfixExpression)
{
   std::stack<double> TokenStack;
   std::vector<std::string> Keywords = InitialiseKeywords();
 
   for(std::vector<std::string>::size_type i = 0; i < PostfixExpression.size(); ++i)
   {
      std::vector<std::string>::iterator it;
 
      if((it = std::find(Keywords.begin(), Keywords.end(), PostfixExpression[i])) == Keywords.end())
      {
         TokenStack.push(std::stod(PostfixExpression[i]));
      }
 
      else if(it->compare("+") == 0)
      {
         double op1 = TokenStack.top();
         TokenStack.pop();
 
         double op2 = TokenStack.top();
         TokenStack.pop();
 
         TokenStack.push(op2 + op1);
      }
 
      else if(it->compare("-") == 0)
      {
         double op1 = TokenStack.top();
         TokenStack.pop();
 
         double op2 = TokenStack.top();
         TokenStack.pop();
 
         TokenStack.push(op2 - op1);
      }
 
      else if(it->compare("*") == 0)
      {
         double op1 = TokenStack.top();
         TokenStack.pop();
 
         double op2 = TokenStack.top();
         TokenStack.pop();
 
         TokenStack.push(op2 * op1);
      }
 
      else if(it->compare("/") == 0)
      {
         double op1 = TokenStack.top();
         TokenStack.pop();
 
         double op2 = TokenStack.top();
         TokenStack.pop();
 
         TokenStack.push(op2 / op1);
      }
   }
 
   return TokenStack.top();
}
 
int main()
{
   //
   std::string SourceExpression;
 
   std::vector<std::string> InfixTokens;
   std::vector<std::string> PostfixTokens;
 
   std::cout << "Input Infix Expression: ";
   std::getline(std::cin, SourceExpression);
 
   InfixTokens = DivideExpressionOnTokens(SourceExpression);
 
   PostfixTokens = ConvertInfixToPostfixNotation(InfixTokens);
 
   std::cout << "Expression in Postfix Notation: ";
   std::copy(PostfixTokens.begin(), PostfixTokens.end(), std::ostream_iterator<std::string>(std::cout, " "));
   std::cout << std::endl;
 
   std::cout << "RESULT: " << CalculatePostfixExpression(PostfixTokens) << std::endl;
 
   system("pause");
   return 0;
}

#include "parser.h"
 
int main()
{
   Parser pars;
   std::list<Token> expr = pars.DivideTextOnTokens("VAL + B/C *       2");
 
   for(auto it = expr.begin(); it != expr.end(); ++it)
      if(it->GetTokenText() != " ")
         std::cout << it->GetTokenText();
   std::cout << std::endl;
 
   system("PAUSE");
}

#include <iostream>
#include <string>
#include <conio.h>
#include <sstream>
const int size=20;
std::ostringstream stm;
void strcpy(char c[], std::string s)
{
    int i;
    for(i=0;i<s.length();i++)
        c[i]=s[i];
    c[i]='\0';
}
class stek
{
    private:
        char array[size];
    public:
        stek();
        void additem(char c);
        void substractitem(void);
        std::string stekins(void);
        char upperitem(void);
};
stek::stek()
{
    for(int i=0;i<size;i++)
        array[i]='\0';
}
void stek::additem(char c)
{
    for(int i=size-1;i>=0;i--)
        array[i]=array[i-1];
    array[0]=c;
}
void stek::substractitem(void)
{
    for(int i=0;i<size-1;i++)
        array[i]=array[i+1];
    array[size-1]='\0';
}
std::string stek::stekins(void)
{
    std::string s0;
    for(int i=0;i<size;i++)
        if(array[i]!='\0')
           s0=s0+array[i]+" ";
    return s0;
}
char stek::upperitem(void)
{
    return array[0];
}
class stek2
{
    private:
        std::string s[size];
    public:
        stek2();
        void addtoken(std::string a);
        void evaluate(void);
        std::string uppertoken(void);
        void substracttoken(void);
        void clear(void);
};
void stek2::clear(void)
{
    for(int i=0;i<size;i++)
        s[i]=" ";
}
stek2::stek2()
{
    for(int i=0;i<size;i++)
        s[i]=" ";
}
void stek2::substracttoken(void)
{
    for(int i=0;i<size-1;i++)
        s[i]=s[i+1];
    s[size-1]=" ";
}
std::string stek2::uppertoken(void)
{
    return s[0];
}
void stek2::addtoken(std::string a)
{
    for(int i=size;i>0;i--)
        if(i!=size)
            s[i]=s[i-1];
    s[0]=a;
}
void stek2::evaluate(void)
{
    char c1[10];
    char c2[10];
    strcpy(c1,s[1]);
    strcpy(c2,s[2]);
    if(s[0]=="+")
    {
        double temp=atof(c1)+atof(c2);
        substracttoken();
        substracttoken();
        substracttoken();
        stm<<temp;
        addtoken(stm.str());
    }
    else if(s[0]=="*")
    {
        double temp=atof(c1)*atof(c2);
        substracttoken();
        substracttoken();
        substracttoken();
        stm<<temp;
        addtoken(stm.str());
    }
    if(s[0]=="-")
    {
        double temp=atof(c2)-atof(c1);
        substracttoken();
        substracttoken();
        substracttoken();
        stm<<temp;
        addtoken(stm.str());
    }
    else if(s[0]=="/")
    {
        double temp=atof(c2)/atof(c1);
        substracttoken();
        substracttoken();
        substracttoken();
        stm<<temp;
        addtoken(stm.str());
    }
}
std::string itorpn(std::string s)
{
    std::string s0;
    stek st;
    for(int i=0;i<s.length();i++)
    {
        if(isdigit(s[i]) && isdigit(s[i+1]))
            s0=s0+s[i];
        else if(isdigit(s[i]))
                 s0=s0+s[i]+" ";
        if(s[i]=='.')
            s0=s0+s[i];
        if(s[i]=='-' && (s[i-1]=='(' || i==0))
        {
            s0=s0+s[i];
            goto skip;
        }
        if(s[i]=='+' || s[i]=='-' || s[i]=='*' || s[i]=='/')
        {
            if((s[i]=='-' || s[i]=='+') && (st.upperitem()=='/' || st.upperitem()=='*'))
            {
                again:
                s0=s0+st.upperitem()+" ";
                st.substractitem();
            }
            if((s[i]=='-' || s[i]=='+') && (st.upperitem()=='/' || st.upperitem()=='*'))
                goto again;
            st.additem(s[i]);
        }
        skip:
        if(s[i]=='(')
            st.additem('(');
        if(s[i]==')')
            {
                while(st.upperitem()!='(')
                {
                    s0=s0+st.upperitem()+" ";
                    st.substractitem();
                }
                st.substractitem();
            }
    }
    s0=s0+st.stekins();
    return s0;
}
int main()
{
    std::string sd;
    std::cin>>sd;
    std::string ss=itorpn(sd);
    int sizee=0;
    for(int k=0;k<ss.length();k++)
    {
        if(ss[k]==' ') sizee++;
    }
    std::string c[sizee];
    int isfree=0;
    for(int i=0;i<ss.length();i++)
    {
        if(ss[i]==' ') isfree++;
        else 
        {
            c[isfree]=c[isfree]+ss[i];
        }
    }
    stek2 st;
    int l=0;
    while(l<sizee)
    {
        st.addtoken(c[l]);
        if(!isdigit(c[l][0]) && isdigit(c[l-1][0]) && isdigit(c[l-2][0]))
            st.evaluate();
        if(!isdigit(st.uppertoken()[0]))
            st.evaluate();
        l++;
    }
    std::cout<<st.uppertoken();
    getch();
    return 0;
}