Enter the total number of variables you will use
4

Assign values to each of them

Assign value to A       2

Assign value to B       3

Assign value to C       4

Assign value to D       5

Enter a postfix expression using above variables
AB+CD+*
Result is 45

Originally Posted by keshaj

i need a progrm in this....InFix to PostFix and PostFix expression evaluation.....program in c.... i really need ur help..

public class PostfixEval 
{

   public static void main(String[] args) 
    {
      
      TextIO.putln("This program can evaluate postfix expressions such as\n");
      TextIO.putln("        2 2 +");
      TextIO.putln("or");
      TextIO.putln("        7.3 89.2 + 9 1.83 * 2 + /\n");
      TextIO.putln("The operators +, -, *, /, and ^ can be used.\n\n");
      
      while (true) 
        {
             // Get and process one line of input from the user.
        TextIO.putln("\n\n\nEnter a postfix expression or press return to end:\n");
        TextIO.put("? ");
        skipSpaces();
        if (TextIO.peek() == '\n') 
          {
               // If the line is empty (except for spaces), we are done.
            break;
        }
        readAndEvaluate(); // Process the input.
        TextIO.getln(); // Discard the end-of-line.
      }
      
      TextIO.putln("\n\nExiting program.");
      
   } // end main();
   
   
   static void skipSpaces() 
    {
        // Skip past any spaces and tabs on the current input line.
        // When this routine returns, the next character is either
        // the end-of-line character, '\n', or is a non-blank.
      while (TextIO.peek() == ' ' || TextIO.peek() == '\t') 
        {
        TextIO.getAnyChar();
      }
   }
   
   
   static void readAndEvaluate()
     {
        // Read one line of input and process it as a postfix expression.
        // If the input is not a legal postfix expression, then an error
        // message is displayed. Otherwise, the value of the expression
        // is displayed. It is assumed that the first character on
        // the input line is a non-blank. (This is checked in the
        // main() routine.)
       
      NumberStack stack; // For evaluating the expression.
      
      stack = new NumberStack(); // Make a new, empty stack.
      
      TextIO.putln();
      
      while (TextIO.peek() != '\n') 
        {
      
          if ( Character.isDigit(TextIO.peek()) ) 
             {
                  // The next item in input is a number. Read it and
                  // save it on the stack.
              double num = TextIO.getDouble();
              stack.push(num);
              TextIO.putln("   Pushed constant " + num);
          }
          else 
             {
                 // Since the next item is not a number, the only thing
                 // it can legally be is an operator. Get the operator
                 // and perform the operation.
              char op; // The operator, which must be +, -, *, /, or ^.
              double x,y;     // The operands, from the stack, for the operation.
              double answer; // The result, to be pushed onto the stack.
              op = TextIO.getChar();
              if (op != '+' && op != '-' && op != '*' && op != '/' && op != '^') 
                  {
                      // The character is not one of the acceptable operations.
                  TextIO.putln("\nIllegal operator found in input: " + op);
                  return;
              }
              if (stack.isEmpty()) 
                  {
                  TextIO.putln("   Stack is empty while trying to evaluate " + op);
                  TextIO.putln("\nNot enough numbers in expression!");
                  return;
              }
              y = stack.pop();
              if (stack.isEmpty()) 
                  {
                  TextIO.putln("   Stack is empty while trying to evaluate " + op);
                  TextIO.putln("\nNot enough numbers in expression!");
                  return;
              }
              x = stack.pop();
              switch (op) 
                  {
                 case '+': answer = x + y; break;
                 case '-': answer = x - y; break;
                 case '*': answer = x * y; break;
                 case '/': answer = x / y; break;
                 default:   answer = Math.pow(x,y); // (op must be '^'.)
              }
              stack.push(answer);
              TextIO.putln("   Evaluated " + op + " and pushed " + answer);
          }
          
          skipSpaces();
      
      } // end while
      
      // If we get to this point, the input has been read successfully.
      // If the expression was legal, then the value of the expression is
      // on the stack, and it is the only thing on the stack.
      
      if (stack.isEmpty()) 
        { // Impossible if the input is really non-empty.
          TextIO.putln("No expression provided.");
          return;
      }
       
      double value = stack.pop(); // Value of the expression.
      TextIO.putln("   Popped " + value + " at end of expression.");

      if (stack.isEmpty() == false) {
          TextIO.putln("   Stack is not empty.");
          TextIO.putln("\nNot enough operators for all the numbers!");
          return;
      }

      TextIO.putln("\nValue = " + value);
      
      
   } // end readAndEvaluate()


} // end class PostfixEval

Originally Posted by abdo

Attached the question,i know for you is simple, but i really need your help...Thank you

#include <iostream>
#include <stack> 
#include <string>
using namespace std;

void main()
{
    int i, choice = 1;
    string postfixExp;
    char token;
    float value, value1, value2;
    stack<float> s; //Declare a stack of floats

   

    while (choice != 0)
    {
        cout << "1. Evaluate a postfix expression" << endl;
        cout << "0. Exit " << endl;
        cout << "Enter the number for the option: ";

        cin >> choice;
        switch(choice)
        {
            case 1: cout << "Evaluate a postfix expression\n";
                    cout << "Enter the expression: ";
                    cin >> postfixExp;
                    i = 0;
                    token = postfixExp[i];
                    while((i < postfixExp.size()) && (token != '='))
                    {
                        if(isdigit(token))
                        {
                            value = token - '0';
                            s.push(value);
                        }
                        else
                        {
                            value2 = s.top();
                            s.pop();
                            value1 = s.top();
                            s.pop();
                            switch(token)
                            {
                                case '+': value = value1 + value2;
                                          break;
                                case '-': value = value1 - value2;
                                          break;
                                case '*': value = value1*value2;
                                          break;
                                case '/': value = value1/value2;
                                          break;
                            }
                            s.push(value);
                        }
               i++;
               token = postfixExp[i];
                    }
                    value = s.top();
                    s.pop();
                    cout << postfixExp << " " << value << endl;         
                    break;

            case 0: cout << "Exiting the program\n";
                    break;

            default: cout << "Invalid option\n";
                    break;
        }
     cout << endl;
    }
}