Meilleure façon de supprimer la hiérarchie des fenêtres parent/enfant

Question

J'ai un système de fenêtre dans une interface graphique, et je ne suis pas sûr de la séquence de destruction. Chaque fenêtre est un vecteur tenant ses enfants, et chacun a aussi un pointeur vers son parent:

auto root = new Window; 
root->addChild(new Window); 
root->addChild(new Window); 
auto child = root->addChild(new Window); // Return value is the newly created Window 
child->addChild(new Window); 
child->addChild(new Window); 
auto grandchild = child->addChild(new Window); 
grandchild->addChild(new Window); 
grandchild->addChild(new Window); 
grandchild->addChild(new Window); 

// Je veux supprimer le pointeur d'enfant, d'abord je dois effacer le pointeur de son enfant de parent de vecteur .

child->parent->children.erase(child->parent->children.begin() + child->positionInParentsVector - 1); 

child->destroy(); 

void Window::destroy() 
{ 
    if (children.size() == 0) delete this; 
    else for (auto i : children) i->destroy(); 
} 

OU avec des vecteurs de pointeurs intelligents, serait-il suffisant pour faire:

// Remove reference of child from parent's children vector, then 

delete child; 

J'ai lu qu'il est correct de faire supprimer ce. C'est difficile de comprendre.

Answer 1

Je pense que vous vous confondez un peu. L'exemple suivant autonome n'a pas de fuites de mémoire:

#include <utility> 
#include <vector> 
#include <memory> 

using std::vector; 
using std::unique_ptr; 

struct Window { 
    Window() = default; 
    vector<unique_ptr<Window>> children; 
    Window* parent = nullptr; 
    ~Window(); 

    Window* addChild(std::unique_ptr<Window> c) { 
     c->parent = this; 
     children.push_back(std::move(c)); 
     return children.back().get(); 
    } 
}; 

Window::~Window() = default; 

int main() { 
    auto root = std::make_unique<Window>(); 
    root->addChild(std::make_unique<Window>()); 
    auto child = root->addChild(std::make_unique<Window>()); 
    child->addChild(std::make_unique<Window>()); 
}; 

Une classe ne peut lui-même contenir, mais il peut contenir un unique_ptr à lui-même (ou des conteneurs de celui-ci). Dans ce schéma, toute la destruction récursive se produit correctement et automatiquement. Vous pouvez l'habiller de différentes manières bien sûr, mais c'est l'idée de base.

Il y a quelques autres questions ici de bonne conception d'objet et de classe et d'encapsulation, mais c'est un autre problème. Note: vous ne devriez pas avoir une méthode appelée destroy dans la grande majorité des cas, mais cela devrait plutôt se produire dans le destructeur.

Il ne devrait en principe jamais être nécessaire d'écrire nouveau ou supprimer en C++ 11 ou plus, sauf si vous écrivez du code de niveau relativement bas (comme votre propre allocateur de mémoire).

Un exemple concret: http://coliru.stacked-crooked.com/a/adef8cc40de4916a