#include <iostream>
#include <fstream>
#include <stdlib.h>
#include "stack.h"
#include <sstream>
 
using namespace std;
 
 
bool isOperand(string expr);
bool isOperator(string expr);
string PostfixToInfix(string expr, stackType<string> stack);
 
 
 
int main()
{
 
stringstream ss;
stackType<string> stack;
string Infix;
string line;
string word;
string expr;
 
 
ifstream inData("input.txt");
ofstream outData("output.txt");
 
while (getline( inData, line ))
{
ss << line;
 
}
while ( ss >> word)
{
stack.push(word);
}
 
outData<<line;
 
 
 
inData.close();
outData.close();
 
system("PAUSE");
return 0;
}
 
 
 
bool isOperand(string expr)
{
 return(!isOperator(expr)? true : false);
}
 
bool isOperator(string expr)
{
 return((expr=="+" || expr=="-" || expr=="*" || expr=="/" || expr=="(" || expr==")")? true : false);
}
 
string PostfixToInfix(string expr,stackType<string> stack)
{
 
 for(int i=0; i<expr.length(); i++)
 {
  if(isOperand(expr[i]))
  {
   stack.push(expr.length()[i]);
  }
  else
  {
   string temp = stack.top();
   stack.pop();
   int stack.push()=stack.top()+expr.length()[i]+temp;
   stack.pop();
   stack.push();
  }
 }
 return(stack.top());
}

#ifndef H_StackType
#define H_StackType
 
#include <iostream>
#include <fstream>
#include <cassert>
 
using namespace std;
 
template<class Type>
 
class stackType
{
 
public:
const stackType<Type>& operator=(const stackType<Type>&);
void initializeStack();
bool isEmptyStack();
bool isFullStack();
void destroyStack();
void push(const Type& newItem);
Type top();
void pop();
stackType(int stackSize = 100);
stackType(const stackType<Type>& otherStack);
~stackType();
bool operator== (const stackType<Type>&);
bool operator!= (const stackType<Type>&);
 
 
 
private:
int maxStackSize;
int stackTop;
Type *list;
void copyStack(const stackType<Type>& otherStack);
bool isEqual(const stackType<Type>&);
 
 
};
 
template<class Type>
void stackType<Type>::copyStack(const stackType<Type>& otherStack)
{
delete [] list;
maxStackSize = otherStack.maxStackSize;
stackTop = otherStack.stackTop;
 
list = new Type[maxStackSize];
assert(list != NULL);
 
for(int j = 0; j < stackTop; j++)
list[j] = otherStack.list[j];
 
}
 
template<class Type>
stackType<Type>::stackType(const stackType<Type>& otherStack)
{
list = NULL;
 
copyStack(otherStack);
 
}
 
template<class Type>
const stackType<Type>& stackType<Type>::operator=(const stackType<Type>& otherStack)
{
if (this != &otherStack)
copyStack(otherStack);
 
return *this;
}
 
template<class Type>
void stackType<Type>::initializeStack()
{
stackTop = 0;
}
 
template<class Type>
void stackType<Type>::destroyStack()
{
stackTop = 0;
}
 
template<class Type>
bool stackType<Type>::isEmptyStack()
{
return(stackTop == 0);
}
template<class Type>
bool stackType<Type>::isFullStack()
{
return(stackTop == maxStackSize);
}
 
template<class Type>
void stackType<Type>::push(const Type& newItem)
{
if(!isFullStack())
{
list[stackTop] = newItem;
 
stackTop++;
}
 
else
cerr<<"Cannot add to a full stack."<<endl;
}
 
template<class Type>
Type stackType<Type>::top()
{
assert(stackTop != 0);
 
return list[stackTop - 1];
}
 
template<class Type>
void stackType<Type>::pop()
{
if(!isEmptyStack())
{
stackTop--;
}
else
cerr<<"Cannot remove from an empty stack."<<endl;
}
 
template<class Type>
stackType<Type>::stackType(int stackSize)
{
if(stackSize <= 0)
{
cerr<<"The size of the array to hold the stack must "
<<"be positive."<<endl;
cerr<<"Creating an array of size 100."<<endl;
 
maxStackSize = 100;
}
 
else
maxStackSize = stackSize;
 
stackTop = 0;
 
list = new Type[maxStackSize];
}
 
template<class Type>
stackType<Type>::~stackType()
{
delete [] list;
}
 
 
 
template<class Type>
bool stackType<Type>::isEqual(const stackType<Type>& otherStack) {
bool bRet = false;
if (otherStack.maxStackSize == maxStackSize && otherStack.stackTop == stackTop){
bRet = true;
for (int j = 0; j < stackTop; ++j) {
if (otherStack.list[j] != list[j]) {
// cout << "!=( " << j << ") " << otherStack.list[j] << "!=" << list[j];
bRet = false;
break;
}
}
}
return bRet;
}
 
template<class Type>
bool stackType<Type>::operator==(const stackType<Type>& otherStack) {
return isEqual(otherStack);
}
 
template<class Type>
bool stackType<Type>::operator!=(const stackType<Type>& otherStack) {
return !isEqual(otherStack); //!(*this == otherStack);
}
 
 
#endif