stacks problem

[malcolmdko]

i wrote a program that is suppposed to take an equation and change it from infix to postfix.. using a .h file. i am having errors saying that i am passing too many arguments into my functions. the book only uses templates and i dont konw how to use templates. someone please give me a few pointers


[u][cpp file/u]

#include<iostream>
#include<iomanip>
#include<fstream>
#include<cassert>
#include "stackprogramH.h"


using namespace std;

void evaluate(ofstream& out, nodeType& stack, char& ch, bool& expressionOK);
void discard(ifstream& in, ofstream& out, char& ch);

int main()
{
    double num, result;
    bool expressionOK;
    char ch;
    double stack(100);
    ifstream infile;
    ofstream outfile;
    
    infile.open("intext.txt");
    
    if(!infile)
    {
              cout<<"cannot open the input file."
                   <<"Program terminates!"<<endl;
                   return 1;
                   }
    outfile.open("output.txt");
    outfile<<fixed<<showpoint;
    outfile<<setprecision(2);
    
    infile>>ch;
    while(infile)
    {
    initializeStack(stack);
    expressionOK = true;
    outfile<<ch;
    
    while(ch != '=')
    {
             switch(ch)
             {
             case '#': infile >>num;
                       outfile<<num<<" ";
                       if(!isFullStack(stack))
                       push(num);
                       else
                       {
                          cout<<"Stack overflow. "
                           <<"program terminates "<<endl;
                           return 1;
                           }
                           break;
                           default: evaluate(outfile, stack, ch, expressionOK);
                           }
                           if(expressionOK)
                           {
                                           infile>>ch;
                                           outfile<<ch;
                                           if(ch != '#')
                                           outfile<<" ";
                                           }
                                           else
                                           discard(infile,outfile,ch);
                                           }
                                           if(expressionOK)
                                           {
                                           if(!isEmptyStack(stack))
                                           {
                           result = top(ch);
                           pop(ch);
                           if(isEmptyStack(stack))
                           outfile<<result<<endl;
                           else
                           outfile<<"(error : too many operands)"<<endl;
                           }
                           else
                           outfile<<"(error in the expression)"<<endl;
                           }
                           else
                           outfile<<"(error in the expression)"<<endl;
                           outfile<<"______________________________"<<endl;
                           
                           infile>>ch;
                             
                           }
                          
                           
                         
                            infile.close();
                           outfile.close();
                           return 0;
                           }
                        void evaluate(ofstream& out, nodeType& stack, char& ch, bool& expressionOK)
                           {
                                double op1, op2;
                                if(isEmptyStack(stack))
                           {
                                out<<"(not enough opperands)";
                                expressionOK=false;
                           }
                                else
                           {
                                    op2 = top(ch);
                                    pop(ch);
                                    
                                    if(isEmptyStack(stack))
                           {
                                                            out<<"(NOT ENOUGH OPERANDS)";
                                                            expressionOK=false;
                           }
                                    else
                           {
                                        op1 = top(ch);
                                        pop(ch);
                                        
                                    
                                    
                                    switch(ch)
                           {
                                              case'+': push(op1+op2, stack);
                                              case'-': push(op1-op2, stack);
                                              case'*': push(op1*op2, stack);
                                              break;
                                              case'/': if(op2!=0)
                                              push(op1/op2, stack);
                                              else
                           {
                                                  out<<" division by 0 ";
                                                  expressionOK= false;
                           }
                                                  break;
                                                  default: out<<" illegal operator";
                                                  expressionOK = false;
                           }
                           }
                           }
                           }
                               void discard( ifstream& in, ofstream& out, char& ch)
                           {
                                     while(ch != '=')
                           {
                                in.get ch;
                                 out<<ch;
                           }
                           }
                           

[u][.h file/u]

struct nodeType
{
       //change this
       char info;
       nodeType *link;
       
       };
       
       nodeType *stackTop;
       void destroyStack()
       {
            nodeType *temp;
            
                     while(stackTop != NULL)
                     {
                     temp = stackTop;
                     stackTop = stackTop->link;
                     delete temp;
                     }
                     }
       
       void initializeStack()//makes stack empty
       {
            destroyStack();
            }
       
       bool isEmptyStack()//checks stack if it is empty
       {
            return(stackTop == NULL);
            }
       
       bool isFullStack()//checks if it i sfull
       {
            return false;
            }
       void push(const char& x, nodeType* stackTop)//pushes element on stack
       {
            
nodeType *newNode;
newNode = new nodeType;
assert(newNode !=NULL);

newNode->info = x;
newNode->link=stackTop;
stackTop=newNode;
}

char top()
{
     assert(stackTop != NULL);
     return stackTop-> info;
}
void pop()
{
     nodeType *temp;
     if(stackTop != NULL)
     {
                 temp = stackTop;
                 stackTop = stackTop->link;
                 delete temp;
                 }
               
     
}

[malcolmdko]

please run this in your compiler to see what im talking about

[Gumbercules]

You are passing the wrong number of parameters in many cases.
push expects a NodeType*, not a NodeType, so pass &stack for the second parameter, or change the function to expect a reference.

[malcolmdko]

ok i think i know what you are saying but i dont know how to change it ... how would i make it work

[kdenisk]

I would suggest using STL stack (the best) or try to use array-based approach (much simpler). See a reference here http://simpleprogrammingtutorials.com/tutorials/stack-array-based.php