C++ File input...and delimiters

[wulfkat]

Ok, I feel like such an idiot with C++...gimme C# or Java any day of the week.

I have a tree program that (works) creates a tree, inorder traverses it, and then prints out messages before deleting the tree (and printing out more messages). That all works.

What doesn't work is the interface from the file to the tree. Uh, let me explain that. When I started this program, I just asked the user to input the tree from the console, easy peasy, right? Well, I actually need to take the data from a file that looks like this...

{ ROOT } //this is one tree
{ ROOT { FRED } } //this is one tree
{ ROOT { FRED { FRED_JUNIOR1 } { FRED_JUNIOR2} } }//this is one tree
{ ROOT
{ FRED
{ FRED_JUNIOR1}
{ FRED_JUNIOR2}
}
{ BARNEY
{ BARNEY_JUNIOR1}
{ BARNEY_JUNIOR2}
}
}// and this is the final tree

Since C++ is uhhh primative, I can't just use a file delimiter and a string tokenizer to strip out the whitespace and add to the tree properly.

My question is simple, how do I take a line and add just the word to the tree while using the open and closed brackets to indicate whether or not it is a new tree?

Here is my code...

#include <iostream>
#include <fstream>
#include <string> 
 
using namespace std;
 
struct tree_node
 {
  char string[100];
  tree_node *left;
  tree_node *right;
 };
 
tree_node *root;
 
void add_to_tree(char string[100]);
void attach_node(tree_node *new_node_ptr);
 
void pre_order(tree_node *current_node);
 
void dispose_of_tree(tree_node *current_node);
 
int main()
{
 
 
    root = NULL; // initialize root of tree to NULL
 
    string line;
     char string[100];
     int length;
    int oCount = 0;
 
    bool flag = true;
     int target, target1, target2;
    ifstream textFile ("tree.txt");
     if (textFile.is_open())
         {
            while (! textFile.eof())
                {
                    getline (textFile, line);
                    for (int x = 0; x < line.length(); x++)
                    {
                        if (line.substr(x) == "R")
                        {
                        cout << line.substr(x) << endl;       
                             }     
 
 
                    }//close for
 
 
                }//close top while
            } //close if 
 
    pre_order(root);
    dispose_of_tree(root);
    textFile.close();
 
    return 0;
}
 
 
 
void add_to_tree(char string[20])
{
 tree_node *new_node_ptr;
 
 new_node_ptr = new tree_node;
 
 // Initialize new node.
 strcpy(new_node_ptr->string, string);
 new_node_ptr->left = NULL;
 new_node_ptr->right = NULL;
 
 if(root == NULL)
  {
   root = new_node_ptr;
  }
 else
  {
   attach_node(new_node_ptr);
  }
}
 
void attach_node(tree_node *new_node_ptr)
{
 tree_node *search_ptr;
 tree_node *follow_ptr;
 
 search_ptr = root;
 follow_ptr = root;
 
 while(search_ptr != NULL)
  {
   follow_ptr = search_ptr;
   if(strcmp(new_node_ptr->string, search_ptr->string) < 0)
    {
     search_ptr = search_ptr->left;
    }
   else
    {
     search_ptr = search_ptr->right;
    }
  }
 if(strcmp(new_node_ptr->string, follow_ptr->string) < 0)
  {
   follow_ptr->left = new_node_ptr;
  }
 else
  {
   follow_ptr->right = new_node_ptr;
  }
}
 
 
 
void pre_order(tree_node *current_node)
{
 if(current_node != NULL)
  {
   cout << "HELLO" <<current_node->  string << endl;
   pre_order(current_node->left);
   pre_order(current_node->right);
  }
}
 
 
 
void dispose_of_tree(tree_node *current_node)
{
 if(!((current_node->left == NULL) && (current_node->right == NULL)))
  {
   if(current_node->right != NULL)
    {
     dispose_of_tree(current_node->right);
    }
   if(current_node->left != NULL)
    {
     dispose_of_tree(current_node->left);
    }
  }
     cout << "GOODBYE" <<current_node->  string << endl;
 delete current_node;
}

[Ganon11]

{ ROOT } //this is one tree
{ ROOT { FRED } } //this is one tree
{ ROOT { FRED { FRED_JUNIOR1 } { FRED_JUNIOR2} } }//this is one tree
{ ROOT
{ FRED
{ FRED_JUNIOR1}
{ FRED_JUNIOR2}
}
{ BARNEY
{ BARNEY_JUNIOR1}
{ BARNEY_JUNIOR2}
}
}// and this is the final tree

When inputting, you can keep a running count of how many open brackets you have by reading character by character. If you find an open bracket '{', add one - if you find a closed bracket '}', subtract one. Every time your total hits 0, you will have finished one tree.

[wulfkat]

Ok, so I tried to do what you said...

while (! textFile.eof())
    {
    getline (textFile, line);    
    if (line.find("{"))
    { 
    oCount ++;
    //cout << oCount << endl;
 
if (line.find("}"))
                                { 
    oCount ++;
    //cout << oCount << endl;
                                }
 
    //add the new string to the tree
      strcpy(string, line.c_str()); 
      add_to_tree(string);

And this is what I get:

HELLO{ ROOT }
HELLO{ ROOT { FRED } }
HELLO{ ROOT { FRED { FRED_JUNIOR1 } { FRED_JUNIOR2} } }
HELLO{ ROOT
HELLO{ FRED
HELLO { FRED_JUNIOR1}
HELLO { BARNEY_JUNIOR1}
HELLO
HELLO { BARNEY_JUNIOR2}
HELLO { FRED_JUNIOR2}
HELLO{ BARNEY
HELLO}
HELLO}
HELLO}
GOODBYE}
GOODBYE}
GOODBYE}
GOODBYE{ BARNEY
GOODBYE { FRED_JUNIOR2}
GOODBYE { BARNEY_JUNIOR2}
GOODBYE
GOODBYE { BARNEY_JUNIOR1}
GOODBYE { FRED_JUNIOR1}
GOODBYE{ FRED
GOODBYE{ ROOT
GOODBYE{ ROOT { FRED { FRED_JUNIOR1 } { FRED_JUNIOR2} } }
GOODBYE{ ROOT { FRED } }
GOODBYE{ ROOT }

which is not right at all....

Please help!

[wulfkat]

further along...no closer to the end...

code now

     if (textFile.is_open())
     {
    while (! textFile.eof())
    {
    getline (textFile, line, ' ');     
 
 
    target = line.find("{",0);///found open brace
    if(target != string::npos)
    {
    oCount ++;
    line.erase(target, 1);
    }
    target1 = line.find("\t",0);  //found tab
    if(target1 != string::npos)
    {
 
                line.erase(target1, 1);
    }
 
    target3 = line.find(" ",0);  //found tab
    if(target1 != string::npos)
 
{
    line.erase(target1, 1);
    }
    target2 = line.find("}",0);//found closed
    if(target2 != string::npos)
    {
 
               oCount --;
    line.erase(target2, 1);                                       }
     //add the new string to the tree
    if (line.length() > 3)
    {
           strcpy(string, line.c_str()); 
          add_to_tree(string);
        }

So now this is the output

HELLO ROOT
HELLO FRED
HELLO BARNEY

HELLO BARNEY_JUNIOR1

HELLO BARNEY_JUNIOR2
}
}

HELLO FRED
HELLO FRED_JUNIOR1
HELLO FRED

HELLO FRED_JUNIOR2
HELLO FRED_JUNIOR1

HELLO FRED_JUNIOR2
}

HELLO ROOT
HELLO ROOT
HELLO ROOT
GOODBYE ROOT
GOODBYE ROOT
GOODBYE ROOT
GOODBYE FRED_JUNIOR2
}

GOODBYE FRED_JUNIOR1

GOODBYE FRED_JUNIOR2
GOODBYE FRED

GOODBYE FRED_JUNIOR1
GOODBYE FRED
GOODBYE BARNEY_JUNIO
}
}

GOODBYE BARNEY_JUNIO

GOODBYE BARNEY

GOODBYE FRED
GOODBYE ROOT