سوال در مورد infix ها

[Super Robot]

[/size]
سلام دوستان سورس برنامه ی تبدیل postfixبه infix میخواستم باc++

[Ghoghnus]

main.cpp

کد:

#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());
}

stack.h

کد:

#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

Postfix to Infix