Add files via upload

Author: TerminalBear

infix.dat

@@ -0,0 +1,4 @@
+(3 + 4)
+((5 + 4) * 8)
+((0 * (1 + 2)) / (3 - (4  +  5))  *  (6 / 7 / (8 * 9)))
+(1 - 3 * (4 + 5 * 6) + 7)

myBet.cpp

@@ -0,0 +1,96 @@
+#include <iostream>
+#include "stack.h"
+#include <fstream>
+
+using namespace std;
+
+string postfix(string in);
+string prefix(string pf);
+bool isFunct(char &curr);
+int comp(char x);
+
+int main()
+{
+	ifstream input("infix.dat");
+	if(input.is_open()){					// if file is open
+	string in;
+	while(getline(input, in)){				// read line by line
+		string pf = postfix(in);			// convert to postfix first
+		cout<< prefix(pf)<<endl;			// convert from postfix to infix
+	}							// end of read
+	input.close();
+	}
+
+    return 0;
+}
+/////////////////////////////////////////////////////////////////////
+
+// parameter:	infix input from infix.dat
+// output: 	returns string in postfix form
+string postfix(string in){
+	stack<char> bet;
+	string result;
+
+	for(int i = 0; i<in.length(); i++){
+		char x = in[i];
+			if(isdigit(x))
+				result += x;
+			else if(x == '(')
+				bet.push('(');
+			else if(x == ')'){
+				while(bet.top()!='('){
+					char y = bet.topAndPop();
+					result += y;
+				}
+			bet.pop();
+			}
+			else if(isFunct(x)){
+				while(!bet.isEmpty() && bet.top() != '(' && comp(in[i]) <= comp(bet.top())){
+					char z = bet.topAndPop();
+					result += z; 
+				}
+			bet.push(x);
+			} 
+	}
+	while(!bet.isEmpty()){
+		result += bet.top();
+		bet.pop();
+	} 
+	return result;
+}
+
+// parameter:	postfix string after conversion
+// output:	returns string in prefix form
+string prefix(string pf){
+	stack<string> temp;
+	string pref;
+	for(int i=0; i<pf.length(); i++){	
+		if(isFunct(pf[i])){
+			string a = temp.topAndPop();
+			string b = temp.topAndPop();
+			string c = pf[i]+ b+ a;
+			temp.push(c);
+		}
+		else{
+			temp.push(string(1, pf[i]));
+		}
+	}
+	while(!temp.isEmpty()){
+		pref += temp.topAndPop();	// build string to return
+	}
+	return pref;
+}
+
+bool isFunct(char &curr){
+        if(curr == '+'|| curr == '-' || curr == '*' || curr == '/')	// from postfix.cpp
+		return true;
+        else
+                return false;
+}
+int comp(char x){							// order of operation precedence s.t. comparable
+	if(x == '*' || x == '/')
+		return 2;
+	else
+		return 1;
+}
+

stack.cpp

@@ -0,0 +1,89 @@
+
+        /**
+         * Construct the stack.
+         */
+        template <class Object>
+        stack<Object>::stack( int capacity ) : theArray( capacity )
+        {
+            topOfstack = -1;
+        }
+
+        /**
+         * Test if the stack is logically empty.
+         * Return true if empty, false otherwise.
+         */
+        template <class Object>
+        bool stack<Object>::isEmpty( ) const
+        {
+            return topOfstack == -1;
+        }
+
+        /**
+         * Test if the stack is logically full.
+         * Return true if full, false otherwise.
+         */
+        template <class Object>
+        bool stack<Object>::isFull( ) const
+        {
+            return topOfstack == theArray.size( ) - 1;
+        }
+
+        /**
+         * Make the stack logically empty.
+         */
+        template <class Object>
+        void stack<Object>::makeEmpty( )
+        {
+            topOfstack = -1;
+        }
+
+        /**
+         * Get the most recently inserted item in the stack.
+         * Does not alter the stack.
+         * Return the most recently inserted item in the stack.
+         * Exception Underflow if stack is already empty.
+         */
+        template <class Object>
+        const Object & stack<Object>::top( ) const
+        {
+            if( isEmpty( ) )
+                throw Underflow( );
+            return theArray[ topOfstack ];
+        }
+
+        /**
+         * Remove the most recently inserted item from the stack.
+         * Exception Underflow if stack is already empty.
+         */
+        template <class Object>
+        void stack<Object>::pop( )
+        {
+            if( isEmpty( ) )
+                throw Underflow( );
+            topOfstack--;
+        }
+
+        /**
+         * Insert x into the stack, if not already full.
+         * Exception Overflow if stack is already full.
+         */
+        template <class Object>
+        void stack<Object>::push( const Object & x )
+        {
+            if( isFull( ) )
+                throw Overflow( );
+            theArray[ ++topOfstack ] = x;
+        }
+
+        /**
+         * Return and remove most recently inserted item from the stack.
+         * Return most recently inserted item.
+         * Exception Underflow if stack is already empty.
+         */
+        template <class Object>
+        Object stack<Object>::topAndPop( )
+        {
+            if( isEmpty( ) )
+                throw Underflow( );
+            return theArray[ topOfstack-- ];
+        }

stack.h

@@ -0,0 +1,40 @@
+using namespace std;
+#include "sexceptions.h"
+#include <vector>
+
+// stack class -- array implementation
+//
+// CONSTRUCTION: with or without a capacity; default is 10
+//
+// ******************PUBLIC OPERATIONS*********************
+// void push( x )         --> Insert x
+// void pop( )            --> Remove most recently inserted item
+// Object top( )          --> Return most recently inserted item
+// Object topAndPop( )    --> Return and remove most recently inserted item
+// bool isEmpty( )        --> Return true if empty; else false
+// bool isFull( )         --> Return true if full; else false
+// void makeEmpty( )      --> Remove all items
+// ******************ERRORS********************************
+// Overflow and Underflow thrown as needed
+
+template <class Object>
+class stack
+{
+	public:
+		explicit stack( int capacity = 10 );
+
+		bool isEmpty( ) const;
+		bool isFull( ) const;
+		const Object & top( ) const;
+
+		void makeEmpty( );
+		void pop( );
+		void push( const Object & x );
+		Object topAndPop( );
+
+	private:
+		vector<Object> theArray;
+		int topOfstack;
+        };
+
+#include "stack.cpp"