LinkBack URL
About LinkBacks
Issue with String input on a Postfix Expressions program. Not sure why I can not figure this out. I'm trying to take a string and use it for evaluating a Postfix Expressions. The input should be blank-separated. I can get the program to run just fine without spaces. However, I just can not get it to work with spaces. I have tried both cin.ignore() and getline( cin, postfixExp). Using the cin.ignore() I get an endless loop and when I use getline( cin, postfixExp) it will not allow me to input data. Below is my whole program. The problem I'm in countering is in the driver.cpp.
Code:/*-- LStack.h -------------------------------------------------------------- This header file defines a Stack data type. Basic operations: constructor: Constructs an empty stack empty: Checks if a stack is empty push: Modifies a stack by adding a value at the top top: Accesses the top stack value; leaves stack unchanged pop: Modifies stack by removing the value at the top display: Displays all the stack elements Note: Execution terminates if memory isn't available for a stack element. --------------------------------------------------------------------------*/ #include <iostream> using namespace std; #ifndef LSTACK #define LSTACK typedef int StackElement; class Stack { public: /***** Function Members *****/ /***** Constructors *****/ Stack(); /*----------------------------------------------------------------------- Construct a Stack object. Precondition: None. Postcondition: An empty Stack object has been constructed (myTop is initialized to a null pointer). ------------------------------------------------------------------------*/ Stack(const Stack & original); //-- Same documentation as in Figure 7.8 /***** Destructor *****/ ~Stack(); /*------------------------------------------------------------------------ Class destructor Precondition: None Postcondition: The linked list in the stack has been deallocated. ------------------------------------------------------------------------*/ /***** Assignment *****/ const Stack & operator= (const Stack & rightHandSide); /*------------------------------------------------------------------------ Assignment Operator Precondition: rightHandSide is the stack to be assigned and is received as a const reference parameter. Postcondition: The current stack becomes a copy of rightHandSide and a const reference to it is returned. ------------------------------------------------------------------------*/ bool empty() const; /*------------------------------------------------------------------------ Check if stack is empty. Precondition: None Postcondition: Returns true if stack is empty and false otherwise. -----------------------------------------------------------------------*/ void push(const StackElement & value); /*------------------------------------------------------------------------ Add a value to a stack. Precondition: value is to be added to this stack Postcondition: value is added at top of stack provided there is space; otherwise, a stack-full message is displayed and execution is terminated. -----------------------------------------------------------------------*/ void display(ostream & out) const; /*------------------------------------------------------------------------ Display values stored in the stack. Precondition: ostream out is open. Postcondition: Stack's contents, from top down, have been output to out. -----------------------------------------------------------------------*/ StackElement top() const; /*------------------------------------------------------------------------ Retrieve value at top of stack (if any). Precondition: Stack is nonempty Postcondition: Value at top of stack is returned, unless the stack is empty; in that case, an error message is displayed and a "garbage value" is returned. -----------------------------------------------------------------------*/ void pop(); /*------------------------------------------------------------------------ Remove value at top of stack (if any). Precondition: Stack is nonempty. Postcondition: Value at top of stack has been removed, unless the stack is empty; in that case, an error message is displayed and execution allowed to proceed. -----------------------------------------------------------------------*/ private: /*** Node class ***/ class Node { public: StackElement data; Node * next; //--- Node constructor Node(StackElement value, Node * link = 0) /*------------------------------------------------------------------- Precondition: None. Postcondition: A Node has been constructed with value in its data part and its next part set to link (default 0). -------------------------------------------------------------------*/ : data(value), next(link) {} }; typedef Node * NodePointer; /***** Data Members *****/ NodePointer myTop; // pointer to top of stack }; // end of class declaration #endif //--- LStack.cpp ------------------------------------------------- #include <new> using namespace std; #include "LStack.h" //--- Definition of Stack constructor Stack::Stack() : myTop(0) {} //--- Definition of Stack copy constructor Stack::Stack(const Stack & original) { myTop = 0; if (!original.empty()) { // Copy first node myTop = new Stack::Node(original.top()); // Set pointers to run through the stacksŐ linked lists Stack::NodePointer lastPtr = myTop, origPtr = original.myTop->next; while (origPtr != 0) { lastPtr->next = new Stack::Node(origPtr->data); lastPtr = lastPtr->next; origPtr = origPtr->next; } } } //--- Definition of Stack destructor Stack::~Stack() { // Set pointers to run through the stack Stack::NodePointer currPtr = myTop, // node to be deallocated nextPtr; // its successor while (currPtr != 0) { nextPtr = currPtr->next; delete currPtr; currPtr = nextPtr; } } //--- Definition of assignment operator const Stack & Stack::operator=(const Stack & rightHandSide) { if (this != &rightHandSide) // check that not st = st { this->~Stack(); // destroy current linked list if (rightHandSide.empty()) // empty stack myTop = 0; else { // copy rightHandSide's list // Copy first node myTop = new Stack::Node(rightHandSide.top()); // Set pointers to run through the stacks' linked lists Stack::NodePointer lastPtr = myTop, rhsPtr = rightHandSide.myTop->next; while (rhsPtr != 0) { lastPtr->next = new Stack::Node(rhsPtr->data); lastPtr = lastPtr->next; rhsPtr = rhsPtr->next; } } } return *this; } //--- Definition of empty() bool Stack::empty() const { return (myTop == 0); } //--- Definition of push() void Stack::push(const StackElement & value) { myTop = new Stack::Node(value, myTop); } //--- Definition of display() void Stack::display(ostream & out) const { Stack::NodePointer ptr; for (ptr = myTop; ptr != 0; ptr = ptr->next) out << ptr->data << endl; } //--- Definition of top() StackElement Stack::top() const { if (!empty()) return (myTop->data); else { cerr << "*** Stack is empty " " -- returning garbage ***\n"; StackElement * temp = new(StackElement); StackElement garbage = *temp; // "Garbage" value delete temp; return garbage; } } //--- Definition of pop() void Stack::pop() { if (!empty()) { Stack::NodePointer ptr = myTop; myTop = myTop->next; delete ptr; } else cerr << "*** Stack is empty -- can't remove a value ***\n"; } /*----driver.cpp---------------------------------------------------------- Driver program to test the Stack class. ----------------------------------------------------------------------*/ #include <iostream> #include <iomanip> #include <string> using namespace std; #include "LStack.h" int main() { Stack s; //Declare a stack of floats int i, choice = 1; string postfixExp; char token; float value, value1, value2; 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 << "\nEvaluate a postfix expression\n"; cout << "Enter postfix expression with tokens separated by blanks: " << endl; cin >> postfixExp; //cin.ignore(); //getline( 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 << "\nThe given postfix expression is " << postfixExp << endl; cout << "\nThe value of the expression is " << value << endl; break; case 0: cout << "Exiting the program\n"; break; default: cout << "Invalid option\n"; break; } cout << endl; } system("pause"); return 0; }
Originally Posted by jimblumberg 
