script calculatrice en C++

#include <cstdlib>
#include <iostream>

using namespace std;

int main()
{
double nombre1, nombre2;
int signe;
float res;

cout << "quel est le premier nombre? " << endl;
cin >> nombre1;
cout << "quel est le deuxieme nombre? " << endl;
cin >> nombre2;
cout << "operation (1=/ 2=* 3=- 4=+)" << endl;
cin >> signe;
if (signe == 1)res = nombre1 / nombre2;
else if (signe == 2)res = nombre1 * nombre2;
else if (signe == 3)res = nombre1 - nombre2;
else if (signe == 4)res = nombre1 + nombre2;
cout << "le resultat est " << res << endl;
system ("pause");
return (0);
}

#include <cstdlib>
#include <iostream>

using namespace std;

int main()
{
double nombre1, nombre2;
int signe;
float res;

cout << "quel est le premier nombre? " << endl;
cin >> nombre1;
cout << "quel est le deuxieme nombre? " << endl;
cin >> nombre2;
cout << "operation (1=/ 2=* 3=- 4=+)" << endl;
cin >> signe;
switch(signe)
{
case 1 : {res = nombre1 / nombre2; break;}
case 2 : {res = nombre1 * nombre2; break;}
case 3 : {res = nombre1 - nombre2; break;}
case 4 : {res = nombre1 + nombre2; break;}
default : break;
}
cout << "le resultat est " << res << endl;
system ("pause");
return (0);
}

#include <iostream>
#include <cctype>
#include <cmath>
#include <stack>
#include <list>


#define OPERATOR 0
#define NUMBER 1

#define SHOW_POSTFIX_NOTATION 1

void stripSpaces(std::string &str)
{
   for(int i=0;i<str.size();i++)
      while(str[i]==' ')
         str.erase(i,1);
}

struct Token
{
   Token(int number)
   {
      this->type = NUMBER;
      this->number = number;
   }
   Token(char op)
   {
      this->type = OPERATOR;
      this->op = op;
   }
   union
   {
      int number;
      char op;
   };
   int type;
};

class Formula
{
   public:
      Formula()
      {
         
      }
      Formula(std::string in)
      {
         insertFormula(in);
      }
      void insertFormula(std::string in)
      {
         std::stack<char> stack;
         std::list<Token> infixFormula = readFormula(in);
         m_formula.clear();
         int count = 0;
         int lastOpPrecedence = 0;
         for(std::list<Token>::iterator i=infixFormula.begin();i!=infixFormula.end();i++)
         {   
            if(stack.empty())
            {
               lastOpPrecedence = 0;
            }
            else
            {
               lastOpPrecedence = getPrecedence(stack.top());
            }
            
            if(i->type==NUMBER)
            {
               m_formula.push_back(*i);
            }
            else if(i->type==OPERATOR)
            {
               if(i->op=='(')
               {
                  stack.push('(');
               }
               else if(i->op==')')
               {
                  while(stack.top() != '(')
                  {
                     m_formula.push_back(Token(stack.top()));
                     stack.pop();
                  }
                  stack.pop();
               }
               else
               {
                  while(getPrecedence(i->op)<=lastOpPrecedence)
                  {
                     m_formula.push_back(Token(stack.top()));
                     stack.pop();
                     if(stack.empty())
                        lastOpPrecedence = 0;
                     else
                        lastOpPrecedence = getPrecedence(stack.top());
                  }
                  stack.push(i->op);
               }
            }
            
         }
         
         while(!stack.empty())
         {
            m_formula.push_back(Token(stack.top()));
            stack.pop();
         }
         
#if SHOW_POSTFIX_NOTATION
         for(std::list<Token>::iterator i=m_formula.begin();i!=m_formula.end();i++)
         {
            if(i->type==NUMBER)
               std::cout<<i->number<<" ";
            else
               std::cout<<i->op<<" ";
         }
         std::cout<<std::endl;
#endif
         
      }
      int evaluate()
      {
         std::stack<int> stack;
         int val1;
         int val2;
         for(std::list<Token>::iterator i=m_formula.begin();i!=m_formula.end();i++)
         {
            if(i->type==NUMBER)
            {
               stack.push(i->number);
            }
            else
            {
               val2=stack.top();
               stack.pop();
               val1=stack.top();
               stack.pop();
               switch(i->op)
               {
                  case '+':
                     stack.push(val1+val2);
                     break;
                  case '-':
                     stack.push(val1-val2);
                     break;
                  case '*':
                     stack.push(val1*val2);
                     break;
                  case '/':
                     stack.push(val1/val2);
                     break;
                  case '^':
                     stack.push((int)round(pow(val1,val2)));
                     break;
               }
            }
         }
         return stack.top();
      }
      
      static int getPrecedence(char op)
      {
         switch(op)
         {
            case '(':
               return 0;
               break;
            case '^':
               return 3;
               break;
            case '/':
               return 2;
               break;
            case '*':
               return 2;
               break;
            case '+':
               return 1;
               break;
            case '-':
               return 1;
               break;
            default:
               return -1;
               break;
         }
      }
      
      static std::list<Token> readFormula(std::string formula)
      {
         int temp;
         int i = 0;
         std::list<Token> retVal;
         stripSpaces(formula);
         while(i<formula.size())
         {
            if(formula[i]=='\0')
            {
               i++;
            }
            else if(isdigit(formula[i]))
            {
               temp = i;
               for(;isdigit(formula[i]);i++);
               retVal.push_back(Token(atoi(formula.substr(temp, i-temp).c_str())));
            }
            else
            {
               retVal.push_back(Token(formula[i]));
               i++;
            }
         }
         return retVal;
      }
   private:
      std::list<Token> m_formula;
};

int main()
{
   std::string input;
   Formula formule;
   std::cout<<"Mini-calculatrice : "quit" pour quitter"<<std::endl;
   do
   {
      getline(std::cin, input);
      if(input!="quit")
      {
         formule.insertFormula(input);
         std::cout<<formule.evaluate()<<std::endl;
      }
   }while(input!="quit");
   return 0;
}

gabriel@IForgotAboutTheName:~/Bureau$ ./calculatrice
Mini-calculatrice : "quit" pour quitter
32*4(on entre l'expression)
32 4 *(formule en RPN)
128(résultat)
21+3^2*(4/2)
21 3 2 ^ 4 2 / * +
39