/************************************************
     Programa Orientado a Objetos para evaluar una expresión en postfijo
     Versión 2: usando constructores y destructores
************************************************/

    #include<iostream.h>
    #include<iomanip.h>
    #include<string.h>
    #include<stdlib.h>

    const char BLANCO = 32;
    const char END_ST = '\0';

    class ClasePila
             {   int tamano;
                 float * cima;
                 float * stack;
               public:
                 ClasePila(void);        //Constructor por defecto
                 ClasePila(int);         //Constructor
                 ~ClasePila(void);       //Destructor
                 int EstaVacia(void);
                 int EstaLlena(void);
                 void Push (float);
                 void Pop (float &);
               };

        ClasePila::ClasePila(int t)
         { tamano = t;
           stack = new float[t];
           cima =NULL;
         }

        ClasePila::ClasePila(void)
         { tamano = 100;
           stack = new float[tamano];
           cima =NULL;       }

        ClasePila::~ClasePila(void)
         { tamano = 0;
           delete stack;
           delete cima;      }

        int ClasePila::EstaVacia(void)
         { return cima==NULL ? 1: 0; }

        int ClasePila::EstaLlena(void)
         { return cima==(stack+tamano) ? 1: 0; }

        void ClasePila::Push (float valor)
         { if (cima==NULL) cima = stack;
                     else  cima++ ;
           *cima = valor;
         }

        void ClasePila::Pop (float &valor)
         {  valor = *cima;
            if (cima==stack) cima=NULL;
            else cima--;       }
 /***********************************************/
     class ClaseCadena
             {   char exp[100];
                 char *st;
               public:
                 void Leete(void);
                 char *DamePalabra(void);
                 int EstasVacia(void);
             };

        void ClaseCadena::Leete(void)
         { cin.getline(exp,100);
           st=exp;     }

        char* ClaseCadena::DamePalabra(void)
         { char* p=st, *palabra;
           int i;
           for (i=0; *(st+i)==BLANCO; i++, p++);
           st=p;
for (i=0; *(st+i)!=BLANCO && *(st+i)!=END_ST; 
   i++, p++);
           palabra = new char[int(p-st) +1];
           for (i=0; st != p; *(palabra + i++)= *(st++) );
           *(palabra+i)=END_ST;
           return palabra;
         }
        int ClaseCadena::EstasVacia(void)
         { return *st == END_ST? 1 :0; }
    /***********************************************/
     int EsOperando(char *);
     float opera(float, char *, float);
   /***********************************************/
    void main (void)
    { ClaseCadena Expresion;
      //ClasePila Pila;
      ClasePila Pila(10);
      char *dato;
      float Resultado;

      cout << "Ingrse expresión : ";
      Expresion.Leete();
      while (!Expresion.EstasVacia())
         { dato= (Expresion.DamePalabra());
           if (EsOperando(dato) )
              Pila.Push(atof(dato));
           else
             { float Dato1, Dato2;
               Pila.Pop(Dato1);
               Pila.Pop(Dato2);
               Pila.Push(opera(Dato2,dato,Dato1));
             }
         }
      Pila.Pop(Resultado);
      cout << "Resultado = " << Resultado << endl;
    }

     int EsOperando(char *op)
      { switch (*op)
         { case '+': case '-': case '*': case '/': return 0;
           default : return 1;
         }
       }

     float opera(float d1, char *op, float d2)
      { switch (*op)
         { case '+': return d1+d2;
           case '-': return d1-d2;
           case '*': return d1*d2;
           case '/': return d1/d2;
           default : return 0;
         }
       }