C++ Binary Tree sérialisation en utilisant les classes

Question

Je suis nouveau ici et je voudrais une petite aide. Je fais mes devoirs en C++ (en utilisant des classes), qui inclut l'arbre de recherche binaire de sérialisation dans le fichier et la désérialisation du fichier. Je me suis coincé.

J'ai programmé l'arbre de recherche binaire et quelques méthodes utiles pour plus tard. Mais j'ai un problème avec la sérialisation de l'arbre de recherche binaire dans un fichier. Merci pour toute aide, conseils et idées !!!

Mon code:

Tree.h:

#include <fstream> 
using namespace std; 

class BinaryTree 
{ 
public: 
    BinaryTree(); 
    ~BinaryTree(); 

    void Insert(int x); 
    void InOrder(); 
    bool Search(int x); 
    void treeToFile(ofstream& file); 

private: 
    struct node 
    { 
     int key; 
     node* left; 
     node* right; 
    }; 
    node* root; 
    void Clear(node* nod); 
    void Insert(int x, node*& nod); 
    void InOrder(node* nod); 
    bool Search(int x, node* nod); 
    void treeToFile(node* nod, ofstream& file); 
}; 

Tree.cpp:

#include "Tree.h" 
#include<iostream> 
#include<fstream> 

using namespace std; 

BinaryTree::BinaryTree() 
{ 
    root = nullptr; 
} 

BinaryTree:: ~BinaryTree() 
{ 
    cout << "Clear Binary Tree" << endl; 
    Clear(root); 
} 

void BinaryTree::Clear(node* nod) 
{ 
    if (nod != nullptr) 
    { 
     Clear(nod->left); 
     Clear(nod->right); 
     cout <<"Deleting node: " <<nod->key << endl; 
     delete nod; 
    } 
} 

void BinaryTree::Insert(int x) 
{ 
    Insert(x, root); 
} 

void BinaryTree::Insert(int x, node*& nod) 
{ 
    if (nod == nullptr) 
    { 
     nod = new node(); 
     nod->left = nullptr; 
     nod->right = nullptr; 
     nod->key = x; 
    } 
    else 
     if (x<nod->key) 
      Insert(x, nod->left); 
     else 
      if (x>nod->key) 
       Insert(x, nod->right); 
} 

bool BinaryTree::Search(int x) 
{ 
    return Search(x, root); 
} 

void BinaryTree::treeToFile(ofstream & file) 
{ 
    return treeToFile(root, file); 
} 

bool BinaryTree::Search(int x, node* nod) 
{ 
    if (nod == nullptr) 
     return false; 

    if (nod->key == x) 
     return true; 

    if (x<nod->key) 
     Search(x, nod->left); 
    else 
     if (x>nod->key) 
      Search(x, nod->right); 
} 

void BinaryTree::InOrder() 
{ 
    cout << "Inorder traversal:" << endl; 
    InOrder(root); 
} 

void BinaryTree::InOrder(node* nod) 
{ 
    if (nod != nullptr) 
    { 
     InOrder(nod->left); 
     cout <<"Node with key: "<<nod->key <<endl; 
     InOrder(nod->right); 
    } 
} 
void BinaryTree::treeToFile(node* root, ofstream& file) 
{ 
    if (!file.is_open()){ 
     cout << "File cannot be opened" << endl; 
    } 
    if (root == NULL) { 
     file << "#" << ";"; 
     return; 
    } 
    file << root->key << ';'; 
    treeToFile(root->left, file); 
    treeToFile(root->right, file); 
    file.close(); 

} 

Main. cpp

#include "Tree.h" 
#include<iostream> 
#include<string> 

using namespace std; 

int main() 
{ 
    BinaryTree* tree = new BinaryTree(); 
    tree->Insert(4); 
    tree->Insert(42); 
    tree->Insert(21); 
    tree->Insert(31); 
    tree->Insert(14); 
    tree->Insert(12); 
    tree->Insert(3); 
    ofstream output("tree.txt"); 
    tree->treeToFile(output); 


    delete tree; 
    return 0; 
} 

Contenu du fichier sérialisé, quand j'ai essayé compilé: 4; 3; #; #; Pour la sérialisation, j'utilise la traversée de précommande selon les instructions de mon enseignant. Mais quand j'ai essayé de stocker les nœuds de l'arbre dans le fichier - il stocke seulement sous-arbre gauche, et dans le compilateur, il dit que le fichier ne peut pas être ouvert.

compilateur montre ceci:

Compiler_result

Answer 1

Vous appelez treeToFile avec un argument de nœud recurisvely mais une fois que vous finissez à gauche et à droite traversant pour la première partie de l'arbre que vous fermez le fichier. De là, vous cliquez sur le fichier d'affirmation if branch ne peut pas être ouvert. Vous devriez fermer le fichier à la toute fin de l'enregistrement, éventuellement déplacer la fermeture de treeToFile en prenant ostream et non la surcharge du noeud et de l'ostream.

De même, vous revenez sur un appel de fonction qui renvoie un vide inutile.