Passing a file into an Expression Tree

[stevecaboose]

First the program will open a file which contains an infix expression that is fully parenthesized. The program will read this line and add it to an expression tree. It will then display the expression in prefix, postfix form and the result of the expression. The issue I am having is that I want the build_tree() in the main program to repeat itself for each line in the file. So if there were two expressions one on each line, it would display the different forms of expression and answer for each one. I have tried using the getline() function but the program crashes. The way I have it set up right now, it works good if there is just one line in the text file. Also it can only handle single digits as input. Any help would be appreciated.


Main

 #include <iostream>
#include "ET.h"
#include <string>
#include <fstream>
#include <algorithm>

using namespace std;

void build_tree(istream& in_f);


int main()
{
    ifstream infile;
    char file_name[100];
    string str;


     cout << "Enter a file name: ";
     cin >> file_name;               // Get file name

     infile.open(file_name);         // Open file
    if(!infile)                     // If we couldn't open the file...
    {
        cout << "Failed to open file." << endl;
        return 0;
    }

build_tree(infile);


infile.close();


    return 0;
}


void build_tree(istream& in_f){

ET e;
string expression;
    while(getline(in_f, expression)){

        e.build(in_f);
        cout << e;
        cout << "\nResult = " << e.computeValue();
    }


}

ET.h

#ifndef ET_H
#define ET_H
#include <istream>
#include <fstream>
using namespace std;

class ET
{
   private:
       struct Node{

            char optr;
            int operand;
            Node *left;
            Node *right;

       };

       Node* root;

       //private function

       Node* help_build(istream& in_s);

       //printing
       void prefix(Node* r, std::ostream& out_s);
       void postfix(Node* r, std::ostream& out_s);
       void infix(Node* r, std::ostream& out_s);

       void destroy(Node* r);

       int eval(Node* x);


   public:

       ET();

       ~ET();

       void build(istream& in_s);


        int computeValue();

        friend std::ostream& operator << (std::ostream& out_s, ET& e);


};



#endif // ET_H 

ET.cpp

#include "ET.h"
#include <istream>
#include <fstream>
using namespace std;
ET::ET(){
    root = NULL;
}

ET::~ET(){
    destroy(root);
}

void ET::destroy(Node *r){

  if(r != NULL)
    {
        destroy(r -> left);
        destroy(r -> right);
        delete r;
    }
}


void ET::build(istream& in_s){

    destroy(root); // make sure the tree is empty
    root = help_build(in_s);


}

ET::Node* ET::help_build(istream& in_s){

    char ch;
    Node* temp;
    in_s>>ch;
    if(isdigit(ch)){

        temp= new Node;
        temp -> operand = ch - '0';
        temp -> left = NULL;
        temp -> right = NULL;

    }else{

        temp = new Node;
        temp -> left = help_build(in_s);
        in_s>> temp -> optr;
        temp -> right = help_build(in_s);
        in_s >> ch; // ')'
    }
    return temp;
}

void ET::prefix(Node* r, ostream& out_s){

    if( r -> left == NULL){ // its a leaf
        out_s << r -> operand << " ";


    }else{
        out_s << r -> optr << " ";
        prefix(r -> left, out_s);
        prefix(r -> right, out_s);
    }
}

void ET::postfix(Node* r, ostream& out_s){

    if( r -> left == NULL){ // its a leaf
        out_s << r -> operand << " ";


    }else{

        postfix(r -> left, out_s);
        postfix(r -> right, out_s);
        out_s << r -> optr << " ";
    }
}

void ET::infix(Node* r, ostream& out_s){

 if( r -> left == NULL){ // its a leaf

        out_s << r -> operand << " ";


    }else{
        out_s << '(';
        infix(r -> left, out_s);
        out_s << r -> optr << " ";
        infix(r -> right, out_s);
        out_s << ')';
    }

}



ostream& operator << (ostream& out_s, ET& e){
    out_s << "Prefix: ";
    e.prefix(e.root, out_s);
    out_s << endl;
    out_s << "Infix: ";
    e.infix(e.root, out_s);

    out_s << endl;
    out_s << "Postfix: ";
    e.postfix(e.root, out_s);




    return out_s;
}

int ET:: eval(Node* x) {

    int result;

    switch (x -> optr) {
       case '+': result = eval(x->left) + eval(x->right);
               break;
       case '-': result = eval(x->left) - eval(x->right);
               break;
       case '*': result = eval(x->left) * eval(x->right);
               break;
       case '/': result = (eval(x->left)) / (eval(x->right));
               break;
       default:
            return x -> operand;

}
 return result;

}


int ET::computeValue(){
    return eval(root);
}

[stevecaboose]

SOLVED:

changed the build_tree function in the main to this:

void build_tree(ifstream& in_f){

ET e;
string expression;

        e.build(in_f);
        cout << e;

        while(getline(in_f, expression)){
            e.build(in_f);
        cout << e;
        }
}