Discussion :

[bruce-willis]

Bonjour les amis !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
#include <qlcdnumber.h>
#include <qslider.h>
 
#include "mywidget.h"
 
MyWidget::MyWidget( QWidget *parent, char *name ) : QVBox( parent, name )
{
  QLCDNumber *lcd = new QLCDNumber( this );
  QSlider *s = new QSlider( QSlider::Horizontal, this );
 
  connect( s, SIGNAL(valueChanged(int)), lcd, SLOT(display(int)) );
}

La plupart des programmeurs de C++ réagiront à ce code, nous faisons un new, mais aucun delete. Il est fait par la classe de base de laquelle nos widgets sont dérivés. Mais je ne comprends pas, comment ? Je pense pas que MFC de Visual C++ ne permet pas de faire ça, donc c'est une spécificité de Qt ?
QMyObject est ici une classe héritant QObject, pourquoi mon code provoque une fuite de mémoire tandis que mon second n'en fait pas :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int main( int argc, char **argv )
{
  // Create an application
  QApplication a( argc, argv );
 
  // Create instances
  QMyObject top( 0, "top" );
  QMyObject *x = new QMyObject( &top, "x" );
  QMyObject *y = new QMyObject( &top, "y" );
  QMyObject *z = new QMyObject( x, "z" );
 
  // Do stuff to stop the optimizer
  top.doStuff();
  x->doStuff();
  y->doStuff();
  z->doStuff();
 
  return 0;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
int main( int argc, char **argv )
{
  // Create an application
  QApplication a( argc, argv );
 
  // Create instances
  QMyObject top( 0, "top" );
  QMyObject *x = new QMyObject( 0, "x" );
  QMyObject *y = new QMyObject( 0, "y" );
  QMyObject *z = new QMyObject( x, "z" );
 
  // Do stuff to stop the optimizer
  top.doStuff();
  x->doStuff();
  y->doStuff();
  z->doStuff();
 
  return 0;
}

[yan]

QMyObject est ici une classe héritant QObject, pourquoi mon code provoque une fuite de mémoire tandis que mon second n'en fait pas :

Bonjour,
pourquoi dit tu que tu as une fuite memoire???

Pour les delete, c'est Qt qui s'en charge. Lors de la création d'un objet Qt,il y as toujours un parent associé qui va géré la vie de cette objet

[Alp]

Dans un code Qt4, on verra souvent un new sans delete associé.

En fait, si une nouvelle instance de QObject est crée et qu'on lui spécifie un parent - le premier argument du constructeur -, c'est ce parent qui sera chargé de la destruction du fils.

La majorité des classes de Qt4 hérite plus ou moins directement de QObject, mais attention, ce n'est pas le cas de toutes. L'indicateur est la possiblité de passer un objet parent au constructeur.

[Aurelien.Regat-Barrel]

Le parent détruit ses enfants.
Un enfant détruit se désenregistre de son parent dans le destructeur.
Si tu détruits le parent, il va détruire en cascade ses fils.

Ce qui explique pourquoi le code suivant pose probleme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
  QMyObject *top = new QMyObject( 0, "top" );
  QMyObject x ( top, "x" );
  delete top; // provoque un delete x...

[bruce-willis]

Salut tout le monde !

Donc si je retiens bien, un composant Qt déclaré dans une classe Qt doit avoir this comme paramètre pour pouvoir être détruit sans delete.

Que se passe-t-il si je mets un delete dans le destructeur de la classe pour désallouer le composant ?

[Aurelien.Regat-Barrel]

J'ai pas compris ta phrase

La regle est simple:

S'il y un new, il faut un delete

Dans le cas de Qt, il y a ce post scriptum:

Qt effectue automatiquement un appel de delete pour les classes contenues dans un conteneur

Donc toutes tes classes Qt que tu crées avec un parent, elles seront automatiquement détruites via un appel a delete.

Probleme: dans l'exemple que je donne, volontairement tordu, la classe x n'a pas été allouée avec new, donc d'apres la 1ere regle ci dessus il ne faut pas faire de delete. C'est équivalent au code suivant:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
QMyObject x;
QMyObject *p_x = &x;
delete p_x; // aie!

Si tu désalloues toi meme un composant, ce composant va se désenregistrer de son conteneur, et donc le conteneur n'essaiera pas de le détruire une deuxieme fois. Voici un exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class MyWidget : public QWidget
{
public:
    MyWidget():
        button4( this ),
        button5( 0 )
    {
         button1 = new QPushButton( this );
         button2 = new QPushButton( 0 );
         button3 = new QPushButton( this );
    }
 
    ~MyWidget()
    {
         delete button1; // facultatif
         delete button2; // obligatoire
         // button3 sera détruit par Qt dans le destructeur de QObject
    }
 
private:
    QPushButton *button1;
    QPushButton *button2;
    QPushButton *button3;
    QPushButton button4;
    QPushButton button5;
};

button1: alloué avec new, en donnant un parent Qt. Du coup si je n'avais pas appelé moi meme delete dans le destructeur de ce parent, il aurait quand meme été effectué un tout petit peu plus tard dans le destructeur de QObject (je crois), exécuté une fois que ~MyWidget(), ~QWidget, etc... aient été exécuté.
Qt ne fera pas un double "delete button1", parce que button1, quand il est détruit, va "s'enlever" de MyWidget.

button2: il n'a pas de parent, donc Qt n'a aucun moyen de savoir quand le détruire, donc il ne le fera pas. Il faut donc soi meme faire un delete.

button3: idem que button1, sauf que cette fois on laisse Qt effectuer le delete

button4 et button5: sont des objets membres de MyWidget. C++ va automatiquement les détruire quand MyWidget est détruit. Ces objets vont alors "s'enlever" de MyWidget, et MyWidget n'essaiera donc pas de faire un delete dessus.