Un destructeur récursif pour une liste chaînée, un arbre, etc. est-il mauvais?

Pour mon exercice d’apprentissage actuel, j’étudie des listes chaînées et des arbres. J’ai récemment vu une suggestion visant à détruire les structures de données de manière récursive en faisant en sorte que chaque nœud supprime son / ses enfants. Cependant, dans presque tous les exemples que j’ai trouvés, le destructeur de noeud est vide et une classe de gestion gère la destruction à l’aide d’une forme d’itération et de suppression. Du sharepoint vue de la fiabilité et / ou du style, y a-t-il quelque chose de fondamentalement mauvais dans le destructeur récursif?

Ce qui suit est ma mise en œuvre de ma compréhension des deux approches.

Destruction récursive:

#include  struct Node { static int count; Node() : num_(count++), p_next_(0) {} ~Node() { std::cout << "entering " << num_ << "\n"; delete p_next_; std::cout << " leaving " << num_ <p_next_ = new Node(); p_head->p_next_->p_next_ = new Node(); delete p_head; return 0; } 

Et voici mon sharepoint vue sur la destruction de la classe de gestion. En supposant que j’ai défini le DTOR suivant pour le nœud:

• Quel casting utiliser; static_cast ou reinterpret_cast?
• Allouer de la mémoire pour un vecteur
• C ++ logique et opérateur
• Pourquoi ma DLL Fortran / C 32 bits ne se comstack-t-elle pas dans MSYS2?
• conversion de double en unsigned int

 ~Node() {std::cout << "Someone deleted " << num_ << "\n";} 

Je définirais la classe de gestion LinkedList suivante et la classe principale suivante

 /* other stuff from above */ class LinkedList { public: LinkedList() : p_head_(new Node()) { p_head_->p_next_ = new Node(); p_head_->p_next_->p_next_ = new Node(); } ~LinkedList() { while(Node* p_prev = p_head_) { p_head_ = p_head_->p_next_; delete p_prev; } } private: Node* p_head_; }; int main () { LinkedList* p_list = new LinkedList(); delete p_list; return 0; } 

En supposant que je lis correctement mes résultats, mes deux implémentations font la même chose.

En ce qui concerne mon exemple de destruction récursive, je pense que j’aurai presque toujours besoin d’une sorte de classe de gestion qui conserve une copie de head lorsque je résous un problème réel avec du code, mais la classe de gestion n’a besoin que de supprimer le nœud de tête / racine de afin d’assurer la destruction de l’ensemble de la structure de données. Cela me semble plus élégant, mais je me suis heurté à des problèmes de code que je pensais bien.

La classe de gestion doit-elle être responsable de s’assurer que tout est supprimé correctement? Ou est-il préférable que la structure de données sous-jacente sache se nettoyer elle-même? Y a-t-il des pièges qui ne sont pas évidents?

Merci!

–Jordan

edit: Une pensée m’est venue. Si j’ai une longue chaîne de nœuds, dois-je m’inquiéter d’un débordement de stack lors de la destruction dans le premier exemple, car la récursivité est en jeu?

edit2: Je suppose que cela aurait dû être évident. Et maintenant je me sens juste un peu bête. Sur ma machine, si j’ai plus de 64 910 nœuds, je tombe en panne. Donc, la récursivité présente clairement un piège.

• Est-il possible d’utiliser #define dans une fonction?
• Données binarys JSONCPP
• Erreur SFML lors du chargement de la police sous Windows
• Existe-t-il un meilleur moyen de renvoyer du texte dans QToolTip que d’utiliser simplement RegExp?
• Comment utiliser des arguments de fonction non nommés en C ou C ++