So I have been asked to write a template class for a binary tree (easy) the hard part is that the nodes have to be written into a file and read in the same exact positions they were in when they were stored. I looked at the array solution with the 2i and 2i+1 concept, but I don't think that works here because the user can add nodes wherever he/she wants to.
I then tried the boost library but I'm getting many errors now. Please help me out. I would prefer to use the boost serialization library. I've tried to have the template class derive from a base class, but that didn't work well.
It is a bit long but I would really like to learn how the boost library serialization works with this. I provided all my files below in the attachments but only copied the binary tree template class to the post. Thank you for your time.
#include <cstdlib> // Provides NULL and size_t
#include <iostream>
#include <fstream>
#include <list>
#include <boost/archive/tmpdir.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/utility.hpp>
#include <boost/serialization/list.hpp>
#include <boost/serialization/assume_abstract.hpp>
using namespace std;
using namespace boost::serialization;
template <class Item>
class binary_tree_node {
public:
// TYPEDEF
typedef Item value_type;
// CONSTRUCTOR
binary_tree_node(
const Item& init_data = Item( ),
binary_tree_node* init_left = NULL,
binary_tree_node* init_right = NULL )
{
root = NULL;
data_field = init_data;
left_field = init_left;
right_field = init_right;
}
// MODIFICATION MEMBER FUNCTIONS
Item& data( ) { return data_field; }
binary_tree_node* left( ) { return left_field; }
binary_tree_node* right( ) { return right_field; }
void set_data(const Item& new_data = Item( )) { data_field = new_data;}
void set_left(binary_tree_node* new_left) { left_field = new_left;}
void set_right(binary_tree_node* new_right) { right_field = new_right; }
// CONST MEMBER FUNCTIONS
const Item& data( ) const { return data_field; }
const binary_tree_node* left( ) const { return left_field; }
const binary_tree_node* right( ) const { return right_field; }
bool is_leaf( ) const
{ return (left_field == NULL) && (right_field == NULL); }
// ORGANIZATION AND PRINT
void printInOrder(binary_tree_node *node)
{
if(node->left() != NULL)
printInOrder(node->left());
//display current iteration
cout << node->data() << endl;
if(node->right() != NULL)
printInOrder(node->right());
}
void insert_leaf(string animal, bool answer, string question)
{
animal = animal.insert(0, "Are you a(n) ");
animal = animal.append("?!");
binary_tree_node<string>
*question_leaf = new binary_tree_node<string>(question),
*animal_leaf = new binary_tree_node<string>(animal),
*placeholder = new binary_tree_node<string>(this->data());
if (answer == true)
{
this->set_right(placeholder);
this->set_left(animal_leaf);
this->set_data(question_leaf->data());
}
if (answer == false)
{
this->set_left(placeholder);
this->set_right(animal_leaf);
this->set_data(question_leaf->data());
}
}
//BOOSTLIB - SERIALIZATION FUNCTIONS
void saveTree()
{
saveLists(root);
ofstream ofs;
ofs.open("animalgame.txt");
boost::archive::text_oarchive oa(ofs);
// write class instance to archive
oa << itemList;
oa << ptrList;
// archive and stream closed when destructors are called
ofs.close();
}
void restoreTree()
{
// create and open an archive for input
ifstream ifs;
ifs.open("animalgame.txt");
boost::archive::text_iarchive ia(ifs);
// read class state from archive
ia >> itemList;
ia >> ptrList;
// archive and stream closed when destructors are called
ifs.close();
}
private:
Item data_field;
binary_tree_node *root;
binary_tree_node *left_field;
binary_tree_node *right_field;
list<Item> itemList;
list<binary_tree_node*> ptrList;
//BOOSTLIB - SERIALIZATION FUNCTIONS
friend class boost::serialization::access;
template<class Archive>
void serialize(Archive & ar, const unsigned int version)
{
ar & itemList;
ar & ptrList;
}
void saveLists(binary_tree_node *node)
{
if(node->left() != NULL){
itemList.push_back(node->data());
ptrList.push_back(node);
saveLists(node->left());
}
if(node->right() != NULL){
itemList.push_back(node->data());
ptrList.push_back(node);
saveLists(node->right());
}
}
};