Gestion de la mémoire dans Qt?

Je suis assez nouveau pour Qt et je me demande sur certains trucs de base avec la gestion de la mémoire et de la vie des objets. Quand dois-je besoin de supprimer et/ou de détruire mes objets? Tout cela est-il géré automatiquement?

Dans l'exemple ci-dessous, laquelle de ces objets, j'ai créer dois-je supprimer? Ce qui se passe à la variable d'instance myOtherClass quand myClass est détruit? Qu'advient-il si je n'ai pas de supprimer (ou détruire) mes objets? Est-ce un problème de mémoire?

MyClass.h

class MyClass
{

public:
    MyClass();
    ~MyClass();
    MyOtherClass *myOtherClass;
};

MyClass.cpp

MyClass::MyClass() {
    myOtherClass = new MyOtherClass();

    MyOtherClass myOtherClass2;

    QString myString = "Hello";
}

Comme vous pouvez le voir c'est tout à fait débutant-facile des trucs, mais où puis-je apprendre à ce sujet dans une manière facile?

InformationsquelleAutor Martin | 2010-03-22
  1. 96

    Si vous construisez votre propre hiérarchie avec QObjects, qui est, vous permet d'initialiser tous les nouveaux QObjects avec un parent,

    QObject* parent = new QObject();
QObject* child = new QObject(parent);

    il suffit ensuite de delete la parent, parce que le parents destructeur prendra soin de détruire child. (Il le fait par l'émission de signaux, de sorte qu'il est en sécurité, même lorsque vous supprimez child manuellement avant que le parent.)

    Vous pouvez également supprimer le premier enfant, l'ordre n'a pas d'importance. Pour un exemple où l'ordre ne question ici de la documentation au sujet de l'objet des arbres.

    Si votre MyClass n'est pas un enfant de QObject, vous aurez à utiliser du C++ façon de faire les choses.

    Notez également que la hiérarchie parent–enfant de QObjects est généralement indépendante de la hiérarchie de la classe C++ hiérarchie/arbre d'héritage. Cela signifie, que attribuée à l'enfant n'a pas besoin d'être une sous-classe de celle du parent. Tout (sous-classe) QObject suffira.

    Il pourrait y avoir certaines contraintes imposées par les constructeurs pour d'autres raisons, cependant, comme dans QWidget(QWidget* parent=0), où le parent doit être un autre QWidget, grâce, par exemple, la visibilité drapeaux et parce que vous souhaitez faire quelques notions de mise en page de cette façon; mais pour Qt hiérarchie du système en général, vous êtes autorisés à QObject en tant que parent.

    • (It does this by issuing signals, so it is safe even when you delete child manually before the parent.) -> Ce n'est pas la raison pour laquelle il est en sécurité. Dans Qt 4.7.4, QObject enfants supprimés directement (via delete, voir qobject.cpp de ligne, 1955). La raison pour laquelle il est préférable de supprimer les objets enfants d'abord est qu'un QObject dit son parent à l'oublier quand il est supprimé.
    • Je voudrais ajouter que vous devez vous assurer que les destructeurs de descendants sont virtuels pour que cela soit vrai. Si ClassB hérite de QObject et ClassC hérite de ClassB, puis ClassC ne s'y détruit par Qt de la relation parent-enfant si ClassB's destructeur est virtuel.
    • Le lien dans la réponse est aujourd'hui cassé (pas surprenant, après près de 4 ans...), c'était peut-être quelque chose comme ceci qt-project.org/doc/qt-4.8/objecttrees.html ?
    • Puisque c'est toujours d'actualité, voici le Qt5 lien: doc.qt.io/qt-5/objecttrees.html <se plaindre>Malheureusement, la nouvelle qt.io site qui héberge le Qt5 docs est profondément ennuyeux à lire que les qt-project.org un.</grognent>
    • QObject du destructeur est déjà virtuel, ce qui fait de chaque sous-classe est destructeur virtuel automatiquement.
    • Même si vous êtes héritant d'une classe avec un nonvirtual destructeur? C'est.... inattendues.
    • Si une classe quelque part dans l'arbre d'héritage est un destructeur virtuel, chaque enfant de la classe ci-dessous ont un destructeur virtuel. Maintenant, si il y a une feuille de classe parent en dehors de ce destructeur virtuel de la chaîne sans un destructeur virtuel, je crois que vous pouvez avoir des problèmes si vous supprimez un pointeur vers cette classe spécifique lorsque l'objet réel est quelque part plus loin sur cette chaîne. Dans le cas d'un enfant de la classe de QObject et la suppression d'un QObject pointeur vers une instance de la classe fille, il n'y a jamais un problème, même si vous oubliez le mot clé virtual dans cette sous-classe le destructeur de déclaration.

    InformationsquelleAutor Debilski
  2. 47

    Je voudrais étendre Debilski réponse en soulignant que le concept de propriété est très importante dans Qt. Quand la classe suppose Une propriété de la classe B, classe B est supprimé lorsque la classe A est supprimé. Il existe plusieurs situations où un objet devient le propriétaire de l'autre, et pas seulement lorsque vous créez un objet et de préciser sa mère.

    Par exemple:

    QVBoxLayout* layout = new QVBoxLayout;
QPushButton someButton = new QPushButton; //No owner specified.
layout->addWidget(someButton); //someButton still has no owner.
QWidget* widget = new QWidget;
widget->setLayout(layout); //someButton is "re-parented".
                           //widget now owns someButton.

    Un autre exemple:

    QMainWindow* window = new QMainWindow;
QWidget* widget = new QWidget; //widget has no owner
window->setCentralWidget(widget); //widget is now owned by window.

    Donc, vérifiez la documentation souvent, il est généralement précise si une méthode d'incidence sur la propriété d'un objet.

    Comme l'a déclaré Debilski, ces règles ne s'appliquent qu'à des objets qui proviennent de QObject. Si votre classe ne découle pas de QObject, vous devrez gérer la destruction de soi-même.

    • Quel est la différence entre l'écriture: QPushButton *someButton = new QPushButton(); ou QPushButton someButton = new QPushButton ou tout simplement QPushButton someButton;
    • Ehh, il y a une énorme différence entre QPushButton *someButton = new QPushButton; et QPushButton someButton;. L'ancien va allouer de l'objet sur le tas, tandis que le second va allouer sur la pile. Il n'y a pas de différence entre les QPushButton *someButton = new QPushButton(); et QPushButton someButton = new QPushButton;, deux d'entre eux d'appeler le constructeur par défaut de l'objet.
    • Je suis très nouveau à ce tellement désolé pour la question, mais quelle est la différence entre "allouer de l'objet sur le tas" et de "l'allouer sur la pile"? Quand devrais-je utiliser le tas et quand dois-je utiliser de la pile? Merci!
    • Vous avez besoin de lire sur les allocations dynamiques, la portée de l'objet et le RAII. Dans le cas de la plaine de C++, vous devez allouer des objets sur la pile à chaque fois que possible, car les objets sont automatiquement détruits quand ils courent hors de portée. Pour les membres de la classe, il est préférable de répartir les objets sur le tas en raison de la performance. Et à chaque fois que vous voulez un objet à "survivre" l'exécution d'une fonction/méthode, vous devez allouer de l'objet sur le tas. Encore une fois, ceux-ci sont très importants sujets qui nécessitent un peu de lecture.
    • La déclaration générale que vous devez allouer des membres de la classe sur le tas pour la performance n'est boeufs. Ça dépend vraiment de la et vous devriez préférer les variables automatique de la durée de stockage jusqu'à ce que vous trouver un problème avec purrformance.
    InformationsquelleAutor Austin
  3. 7

    Parent(soit de QObject, objet ou sa classe dérivée) a une liste de pointeur à ses enfants(QObject/ses dérivés). Le parent va supprimer tous les objets dans sa liste d'enfants tandis que le parent est détruit.
    Vous pouvez utiliser cette propriété de QObject pour enfants, objets de supprimer automatiquement lorsque le parent est supprimé.
    La relation peut être établie en utilisant le code suivant

    QObject* parent = new QObject();
QObject* child = new QObject(parent);
delete parent;//all the child objects will get deleted when parent is deleted, child object which are deleted before the parent object is removed from the parent's child list so those destructor will not get called once again.

    Il y a d'autres façon de gérer la mémoire dans Qt, à l'aide de smartpointer. L'article suivant décrit les différents pointeurs intelligents dans Qt.
    https://blog.qt.digia.com/blog/2009/08/25/count-with-me-how-many-smart-pointer-classes-does-qt-have/

    InformationsquelleAutor yesraaj
  4. -2

    À ajouter sur ces réponses, pour vérification, je vous recommande d'utiliser Visual Leak Detetor bibliothèque pour votre Visual c++ projets, y compris Qt projets depuis son basé sur le c++, cette bibliothèque est compatible avec new, delete, free and malloc états, il est bien documenté et facile à utiliser. N'oubliez pas que lorsque vous créez votre propre QDialog ou QWidget interface héritée de la classe, et puis créer un nouvel objet de cette classe, n'oubliez pas d'exécuter setAttribute(Qt::WA_DeleteOnClose) fonction de votre objet.

    InformationsquelleAutor Khaled