Les QLayout sont-ils vraiment une bonne pratique ? Trop de pointeurs pour déclarer les widgets ?

**pezimad** · 15/09/2013, 11h42

Bonjour,

Je suis un utilisateur débutant de Qt 5.1 j'ai essayé de créer une forme de fenêtre un peu complexe pour s'entrainer a utiliser les QLyouts.

J'ai mis l'image du résultat visuel dans la pièce jointe et voici les codes:

main.cpp :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
#include "mainwindow.h"
#include <QApplication>
 
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    w.showMaximized();
 
    return a.exec();
}

mainwindow.h

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
27
28
29
30
31
32
33
34
35
36
37
38
39
 
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
 
#include <QMainWindow>
#include <QCoreApplication>
#include <QIcon>
#include <QWidget>
#include <QHBoxLayout>
#include <QVBoxLayout>
 
 
 
class MainWindow : public QMainWindow
{
    Q_OBJECT
 
public:
    MainWindow(QWidget *parent = 0);
    ~MainWindow();
 
private:
    QWidget *widget1;
    QWidget *widget2;
    QWidget *widget3;
    QWidget *widget4;
    QWidget *widget5;
    QWidget *widget6;
    QWidget *widget7;
    QWidget *widget8;
    QWidget *widget9;
    QVBoxLayout *vBoxLayout1;
    QVBoxLayout *vBoxLayout2;
    QHBoxLayout *hBoxLayout1;
    QHBoxLayout *hBoxLayout2;
 
};
 
#endif // MAINWINDOW_H

mainwindow.cpp :

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
#include "mainwindow.h"
 
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
{
    this->setWindowIcon(QIcon(QCoreApplication::applicationDirPath() + "/icon.png"));
    this->setWindowTitle("Ma première vraie fenêtre");
 
    widget1 = new QWidget;
    vBoxLayout1 = new QVBoxLayout;
 
    widget2 = new QWidget;
    widget3 = new QWidget;
    widget4 = new QWidget;
    widget5 = new QWidget;
    widget6 = new QWidget;
    widget7 = new QWidget;
    widget8 = new QWidget;
    widget9 = new QWidget;
 
    widget2->setStyleSheet("background-color:#69bf3a;");
    widget3->setStyleSheet("background-color:#009fff;");
    widget4->setStyleSheet("background-color:#ffc484;");
    widget5->setStyleSheet("background-color:#db0000;");
    widget6->setStyleSheet("background-color:#f1df11;");
    widget7->setStyleSheet("background-color:#e2a4ff;");
    widget8->setStyleSheet("background-color:#ffffff;");
    widget9->setStyleSheet("background-color:#000000;");
 
 
    QSizePolicy sizePolicy_widget2(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget2.setVerticalStretch(1);
    widget2->setSizePolicy(sizePolicy_widget2);
    vBoxLayout1->addWidget(widget2);
 
    QSizePolicy sizePolicy_widget3(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget3.setVerticalStretch(5);
    widget3->setSizePolicy(sizePolicy_widget3);
    vBoxLayout1->addWidget(widget3);
 
    hBoxLayout1 = new QHBoxLayout;
    widget3->setLayout(hBoxLayout1);
 
    QSizePolicy sizePolicy_widget4(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget4.setHorizontalStretch(2);
    widget4->setSizePolicy(sizePolicy_widget4);
    hBoxLayout1->addWidget(widget4);
 
    QSizePolicy sizePolicy_widget5(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget5.setHorizontalStretch(4);
    widget5->setSizePolicy(sizePolicy_widget5);
    hBoxLayout1->addWidget(widget5);
 
    vBoxLayout2 = new QVBoxLayout;
    widget5->setLayout(vBoxLayout2);
 
    QSizePolicy sizePolicy_widget6(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget6.setVerticalStretch(4);
    widget6->setSizePolicy(sizePolicy_widget6);
    vBoxLayout2->addWidget(widget6);
 
    QSizePolicy sizePolicy_widget7(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget7.setVerticalStretch(1);
    widget7->setSizePolicy(sizePolicy_widget7);
    vBoxLayout2->addWidget(widget7);
 
    hBoxLayout2 = new QHBoxLayout;
    widget6->setLayout(hBoxLayout2);
 
    QSizePolicy sizePolicy_widget8(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget8.setHorizontalStretch(3);
    widget8->setSizePolicy(sizePolicy_widget8);
    hBoxLayout2->addWidget(widget8);
 
    QSizePolicy sizePolicy_widget9(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget9.setHorizontalStretch(1);
    widget9->setSizePolicy(sizePolicy_widget9);
    hBoxLayout2->addWidget(widget9);
 
 
 
    widget1->setLayout(vBoxLayout1);
    this->setCentralWidget(widget1);
}
 
MainWindow::~MainWindow()
{
}

j'ai quelques questions à vous poser :

1- Est-ce que j'ai utilisé correctement les QLayouts pour diviser cette fenêtre ?

2- Vous ne trouvez pas l'utilisation des QLayouts un peu trop verbeuse ?

3- Dans un autre sujet je remarque dans les tutoriels que les développeurs Qt ont tendance de déclarer les Widgets sous forme de pointeurs. Qt s’en charger d'écrire a notre place les deletes dans le destructeur mais ou est l'intérêt de tout ça ? pour quoi ne pas faire tout simplement :

Code :

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

1
2
 
QPushButton pushButton;

avant d'utiliser le widget ?

Code :

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

1
2
 
pushButton.setText("xgdfgdgf");

**koala01** · 15/09/2013, 22h07

Salut

Envoyé par pezimad

Bonjour,

Je suis un utilisateur débutant de Qt 5.1 j'ai essayé de créer une forme de fenêtre un peu complexe pour s'entrainer a utiliser les QLyouts.

J'ai mis l'image du résultat visuel dans la pièce jointe et voici les codes:

De manière générale, le QLayout servent à s'assurer la disposition correcte des différents élément de ta fenêtre, donc, oui, tu sembles (à voir l'image) les utilier correctement

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
27
28
29
30
31
32
33
34
35
36
37
38
39
 
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
 
#include <QMainWindow>
#include <QCoreApplication>
#include <QIcon>
#include <QWidget>
#include <QHBoxLayout>
#include <QVBoxLayout>
 
 
 
class MainWindow : public QMainWindow
{
    Q_OBJECT
 
public:
    MainWindow(QWidget *parent = 0);
    ~MainWindow();
 
private:
    QWidget *widget1;
    QWidget *widget2;
    QWidget *widget3;
    QWidget *widget4;
    QWidget *widget5;
    QWidget *widget6;
    QWidget *widget7;
    QWidget *widget8;
    QWidget *widget9;
    QVBoxLayout *vBoxLayout1;
    QVBoxLayout *vBoxLayout2;
    QHBoxLayout *hBoxLayout1;
    QHBoxLayout *hBoxLayout2;
 
};
 
#endif // MAINWINDOW_H

A ceci près que tu n'as peut être pas besoin de garder un pointeur sur tes layout en permanence (tu as déjà un pointeur vers les éléments de la fenêtre, pourquoi voudrais tu être en mesure d'accéder aux layouts une fois qu'ils sont placés ?), c'est cohérent avec ce que tu veux obtenir
mainwindow.cpp :

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
#include "mainwindow.h"
 
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
{
    this->setWindowIcon(QIcon(QCoreApplication::applicationDirPath() + "/icon.png"));
    this->setWindowTitle("Ma première vraie fenêtre");
 
    widget1 = new QWidget;
    vBoxLayout1 = new QVBoxLayout;
 
    widget2 = new QWidget;
    widget3 = new QWidget;
    widget4 = new QWidget;
    widget5 = new QWidget;
    widget6 = new QWidget;
    widget7 = new QWidget;
    widget8 = new QWidget;
    widget9 = new QWidget;
 
    widget2->setStyleSheet("background-color:#69bf3a;");
    widget3->setStyleSheet("background-color:#009fff;");
    widget4->setStyleSheet("background-color:#ffc484;");
    widget5->setStyleSheet("background-color:#db0000;");
    widget6->setStyleSheet("background-color:#f1df11;");
    widget7->setStyleSheet("background-color:#e2a4ff;");
    widget8->setStyleSheet("background-color:#ffffff;");
    widget9->setStyleSheet("background-color:#000000;");
 
 
    QSizePolicy sizePolicy_widget2(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget2.setVerticalStretch(1);
    widget2->setSizePolicy(sizePolicy_widget2);
    vBoxLayout1->addWidget(widget2);
 
    QSizePolicy sizePolicy_widget3(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget3.setVerticalStretch(5);
    widget3->setSizePolicy(sizePolicy_widget3);
    vBoxLayout1->addWidget(widget3);
 
    hBoxLayout1 = new QHBoxLayout;
    widget3->setLayout(hBoxLayout1);
 
    QSizePolicy sizePolicy_widget4(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget4.setHorizontalStretch(2);
    widget4->setSizePolicy(sizePolicy_widget4);
    hBoxLayout1->addWidget(widget4);
 
    QSizePolicy sizePolicy_widget5(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget5.setHorizontalStretch(4);
    widget5->setSizePolicy(sizePolicy_widget5);
    hBoxLayout1->addWidget(widget5);
 
    vBoxLayout2 = new QVBoxLayout;
    widget5->setLayout(vBoxLayout2);
 
    QSizePolicy sizePolicy_widget6(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget6.setVerticalStretch(4);
    widget6->setSizePolicy(sizePolicy_widget6);
    vBoxLayout2->addWidget(widget6);
 
    QSizePolicy sizePolicy_widget7(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget7.setVerticalStretch(1);
    widget7->setSizePolicy(sizePolicy_widget7);
    vBoxLayout2->addWidget(widget7);
 
    hBoxLayout2 = new QHBoxLayout;
    widget6->setLayout(hBoxLayout2);
 
    QSizePolicy sizePolicy_widget8(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget8.setHorizontalStretch(3);
    widget8->setSizePolicy(sizePolicy_widget8);
    hBoxLayout2->addWidget(widget8);
 
    QSizePolicy sizePolicy_widget9(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget9.setHorizontalStretch(1);
    widget9->setSizePolicy(sizePolicy_widget9);
    hBoxLayout2->addWidget(widget9);
 
 
 
    widget1->setLayout(vBoxLayout1);
    this->setCentralWidget(widget1);
}
 
MainWindow::~MainWindow()
{
}

[/QUOTE]Juste une petite remarque en ce qui concerne la lisibilité:

Ton constructeur fait tout et on s'étonnerait presque qu'il ne nous serve pas le café en plus.

Tu es tout à fait en droit d'appeler des fonctions membres de ta classe dans le constructeur, et c'est souvent utile lorsqu'on demande au constructeur d'en faire beaucoup.

Ainsi, tu aurais très bien pu créer une fonction (privée) "setAllBackground" qui se serait contentée de définir les couleurs de background pour tous tes widget, et que tu aurais appelée dans ton constructeur.

On aurait pu suivre le même raisonnement pour regrouper toutes les instructions qui on trait à la politique d'élargissement des widgets, et ainsi de suite

Cela aurait eu pour résultat d'avoir un constructeur (beaucoup plus lisible) proche de

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
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
{
    this->setWindowIcon(QIcon(QCoreApplication::applicationDirPath() + "/icon.png"));
    this->setWindowTitle("Ma première vraie fenêtre");
 
    widget1 = new QWidget;
    vBoxLayout1 = new QVBoxLayout;
 
    widget2 = new QWidget;
    widget3 = new QWidget;
    widget4 = new QWidget;
    widget5 = new QWidget;
    widget6 = new QWidget;
    widget7 = new QWidget;
    widget8 = new QWidget;
    widget9 = new QWidget;
    setAllBackGround() // tous les background sont définis dans cette fonction
    setAllPolicies() // tous les setPolicy et similaires sont placé dans cette fonction
    placeAllWidgets() //place les bon widget dans le bon layout
    placeAllLayouts() // imbrique correctement les layouts
}

Selon cet exemple, tu aurais donc quatre fonction qui font chacune une chose bien particulière.

Cette manière de travailler tient beaucoup d'une politique qu'il est urgent d'apprendre très tôt dans l'apprentissage du développement : chaque classe et chaque fonction ne doit avoir qu'une et une seule responsabilité, mais doit la prendre en charge correctement.

Cela s'appelle le SRP: (Single Responsability Principle, ou si tu préfères en francais le principe de la responsabilité unique)

j'ai quelques questions à vous poser :

1- Est-ce que j'ai utilisé correctement les QLayouts pour diviser cette fenêtre ?

A priori, oui.

Il y avait peut etre une autre solution qui aurait utilisé QVHBoxLayout (si elle existe encore du moins

) mais elle n'aurait sans doute pas été plus simple

2- Vous ne trouvez pas l'utilisation des QLayouts un peu trop verbeuse ?

Dés qu'il s'agit de construire une interface graphique, c'est d'office fort verbeux

3- Dans un autre sujet je remarque dans les tutoriels que les développeurs Qt ont tendance de déclarer les Widgets sous forme de pointeurs. Qt s’en charger d'écrire a notre place les deletes dans le destructeur mais ou est l'intérêt de tout ça ? pour quoi ne pas faire tout simplement :

Code :

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

1
2
 
QPushButton pushButton;

avant d'utiliser le widget ?

Code :

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

1
2
 
pushButton.setText("xgdfgdgf");

tu pourrais si tu n'envisageais pas de placer ton bouton dans un layout.

Le problème, c'est que si tu crées cinq boutons, et que tu ne les place pas dans un layout, ils se retrouveront tous "les uns sur les autres" dans le coin supérieur gauche de ta fenêtre.

Ce qu'il faut savoir, c'est que chaque fois que tu "donne" un objet "contenu"(ex : un bouton) à un objet "contenant"(ex : un layout), l'objet "contenant" devient le "propriétaire légal" de l'objet contenu.

A ce titre, c'est donc le layout qui se chargera par défaut de détruire tous les boutons qu'on lui aura donné.

Et cette destruction, comme tu l'as si bien remarqué, passera par un delete.

Or, delete ne fonctionne que sur des objets créés avec new. Invoquer delete sur un pointeur vers un objet qui n'a pas été créé avec new provoque ce que l'on appelle un "comportement indéfini" (undefined behaviour) qui, dans le cas présent, se traduit par une erreur de segmentation (un beau plantage direct de l'application, sans qu'il soit possible d'y faire quoi que ce soit).

De même, lorsque tu fais this->setLayout(unLayout) dans le constructeur de ta classe, ta classe devient le "propriétaire légal" de unLayout, avec exactement le même comportement que celui que je viens d'indiquer.

Au final, c'est parce que ta classe MainWindow est propriétaire du layout "général" qui est lui-même propriétaire des objets que tu lui auras donné et que chacun des objets que tu auras donnés au layout général est lui-même propriétaire des objets que tu leur auras donnés que tout fonctionne correctement :

A la destruction de MainWindow, cette dernière détruit le layout dont elle est propriétaire qui, lors de sa destruction décide de détruire les objets dont il est propriétaire, et ainsi de suite.

Si tu donnes ne serait-ce qu'un pointeur vers un objet qui n'a pas été créé par new à un seul objet, ton code partira "en cacahouètes"

**pezimad** · 16/09/2013, 17h47

Bonjour,

Merci Philippe pour votre repense.

J'ai refait le code pour avoir une meilleure organisation et voici la nouvelle version du logiciel

mainwindow.h :

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
 
#include <QMainWindow>
#include <QWidget>
#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QPushButton>
 
 
 
class MainWindow : public QMainWindow
{
    Q_OBJECT
 
public:
    MainWindow(QWidget *parent = 0);
    ~MainWindow();
 
private:
    QWidget *widget1;
    QWidget *widget2;
    QWidget *widget3;
    QWidget *widget4;
    QWidget *widget5;
    QWidget *widget6;
    QWidget *widget7;
    QWidget *widget8;
    QWidget *widget9;
    QVBoxLayout *vBoxLayout1;
    QVBoxLayout *vBoxLayout2;
    QHBoxLayout *hBoxLayout1;
    QHBoxLayout *hBoxLayout2;
 
    void setAllBackGround();
    void setAllPolicies();
    void placeAllWidgets();
    void placeAllLayouts();
 
};
 
#endif // MAINWINDOW_H

mainwindow.cpp :

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
 
#include "mainwindow.h"
 
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
{
 
    widget1 = new QWidget;
    widget2 = new QWidget;
    widget3 = new QWidget;
    widget4 = new QWidget;
    widget5 = new QWidget;
    widget6 = new QWidget;
    widget7 = new QWidget;
    widget8 = new QWidget;
    widget9 = new QWidget;
 
    vBoxLayout1 = new QVBoxLayout;
    hBoxLayout1 = new QHBoxLayout;
    vBoxLayout2 = new QVBoxLayout;
    hBoxLayout2 = new QHBoxLayout;
 
 
    setAllBackGround(); // tous les background sont définis dans cette fonction
    setAllPolicies(); // tous les setPolicy et similaires sont placé dans cette fonction
    placeAllWidgets(); //place les bon widget dans le bon layout
    placeAllLayouts(); // imbrique correctement les layouts
 
 
    this->setCentralWidget(widget1);
}
 
MainWindow::~MainWindow()
{
}
 
void MainWindow::setAllBackGround()
{
    widget2->setStyleSheet("background-color:#69bf3a;");
    widget3->setStyleSheet("background-color:#009fff;");
    widget4->setStyleSheet("background-color:#ffc484;");
    widget5->setStyleSheet("background-color:#db0000;");
    widget6->setStyleSheet("background-color:#f1df11;");
    widget7->setStyleSheet("background-color:#e2a4ff;");
    widget8->setStyleSheet("background-color:#ffffff;");
    widget9->setStyleSheet("background-color:#000000;");
}
 
void MainWindow::setAllPolicies()
{
    QSizePolicy sizePolicy_widget2(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget2.setVerticalStretch(1);
    widget2->setSizePolicy(sizePolicy_widget2);
 
    QSizePolicy sizePolicy_widget3(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget3.setVerticalStretch(5);
    widget3->setSizePolicy(sizePolicy_widget3);
 
    QSizePolicy sizePolicy_widget4(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget4.setHorizontalStretch(2);
    widget4->setSizePolicy(sizePolicy_widget4);
 
    QSizePolicy sizePolicy_widget5(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget5.setHorizontalStretch(4);
    widget5->setSizePolicy(sizePolicy_widget5);
 
    QSizePolicy sizePolicy_widget6(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget6.setVerticalStretch(4);
    widget6->setSizePolicy(sizePolicy_widget6);
 
    QSizePolicy sizePolicy_widget7(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget7.setVerticalStretch(1);
    widget7->setSizePolicy(sizePolicy_widget7);
 
    QSizePolicy sizePolicy_widget8(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget8.setHorizontalStretch(3);
    widget8->setSizePolicy(sizePolicy_widget8);
 
    QSizePolicy sizePolicy_widget9(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget9.setHorizontalStretch(1);
    widget9->setSizePolicy(sizePolicy_widget9);
}
 
void MainWindow::placeAllWidgets()
{
    vBoxLayout1->addWidget(widget2);
    vBoxLayout1->addWidget(widget3);
    hBoxLayout1->addWidget(widget4);
    hBoxLayout1->addWidget(widget5);
    vBoxLayout2->addWidget(widget6);
    vBoxLayout2->addWidget(widget7);
    hBoxLayout2->addWidget(widget8);
    hBoxLayout2->addWidget(widget9);
}
 
void MainWindow::placeAllLayouts()
{
    widget1->setLayout(vBoxLayout1);
    widget3->setLayout(hBoxLayout1);
    widget5->setLayout(vBoxLayout2);
    widget6->setLayout(hBoxLayout2);
}

J'ai modifié le code précédent pour éviter d'utiliser les pointeurs sur les éléments de la classe MainWindow le résultat est parfait tout marche très bien!

mainwindow.h :

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
 
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
 
#include <QMainWindow>
#include <QWidget>
#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QPushButton>
 
 
 
class MainWindow : public QMainWindow
{
    Q_OBJECT
 
public:
    MainWindow(QWidget *parent = 0);
    ~MainWindow();
 
private:
    QWidget widget1;
    QWidget widget2;
    QWidget widget3;
    QWidget widget4;
    QWidget widget5;
    QWidget widget6;
    QWidget widget7;
    QWidget widget8;
    QWidget widget9;
    QVBoxLayout vBoxLayout1;
    QVBoxLayout vBoxLayout2;
    QHBoxLayout hBoxLayout1;
    QHBoxLayout hBoxLayout2;
 
    void setAllBackGround();
    void setAllPolicies();
    void placeAllWidgets();
    void placeAllLayouts();
 
};
 
#endif // MAINWINDOW_H

mainwindow.cpp :

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
 
#include "mainwindow.h"
 
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
{
    setAllBackGround(); // tous les background sont définis dans cette fonction
    setAllPolicies(); // tous les setPolicy et similaires sont placé dans cette fonction
    placeAllWidgets(); //place les bon widget dans le bon layout
    placeAllLayouts(); // imbrique correctement les layouts
 
    this->setCentralWidget(&widget1);
}
 
MainWindow::~MainWindow()
{
}
 
void MainWindow::setAllBackGround()
{
    widget2.setStyleSheet("background-color:#69bf3a;");
    widget3.setStyleSheet("background-color:#009fff;");
    widget4.setStyleSheet("background-color:#ffc484;");
    widget5.setStyleSheet("background-color:#db0000;");
    widget6.setStyleSheet("background-color:#f1df11;");
    widget7.setStyleSheet("background-color:#e2a4ff;");
    widget8.setStyleSheet("background-color:#ffffff;");
    widget9.setStyleSheet("background-color:#000000;");
}
 
void MainWindow::setAllPolicies()
{
    QSizePolicy sizePolicy_widget2(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget2.setVerticalStretch(1);
    widget2.setSizePolicy(sizePolicy_widget2);
 
    QSizePolicy sizePolicy_widget3(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget3.setVerticalStretch(5);
    widget3.setSizePolicy(sizePolicy_widget3);
 
    QSizePolicy sizePolicy_widget4(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget4.setHorizontalStretch(2);
    widget4.setSizePolicy(sizePolicy_widget4);
 
    QSizePolicy sizePolicy_widget5(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget5.setHorizontalStretch(4);
    widget5.setSizePolicy(sizePolicy_widget5);
 
    QSizePolicy sizePolicy_widget6(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget6.setVerticalStretch(4);
    widget6.setSizePolicy(sizePolicy_widget6);
 
    QSizePolicy sizePolicy_widget7(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget7.setVerticalStretch(1);
    widget7.setSizePolicy(sizePolicy_widget7);
 
    QSizePolicy sizePolicy_widget8(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget8.setHorizontalStretch(3);
    widget8.setSizePolicy(sizePolicy_widget8);
 
    QSizePolicy sizePolicy_widget9(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget9.setHorizontalStretch(1);
    widget9.setSizePolicy(sizePolicy_widget9);
}
 
void MainWindow::placeAllWidgets()
{
    vBoxLayout1.addWidget(&widget2);
    vBoxLayout1.addWidget(&widget3);
    hBoxLayout1.addWidget(&widget4);
    hBoxLayout1.addWidget(&widget5);
    vBoxLayout2.addWidget(&widget6);
    vBoxLayout2.addWidget(&widget7);
    hBoxLayout2.addWidget(&widget8);
    hBoxLayout2.addWidget(&widget9);
}
 
void MainWindow::placeAllLayouts()
{
    widget1.setLayout(&vBoxLayout1);
    widget3.setLayout(&hBoxLayout1);
    widget5.setLayout(&vBoxLayout2);
    widget6.setLayout(&hBoxLayout2);
}

Normalement la règle générale c'est de créer des propriétés de classe variables je ne comprends toujours pas la raison de déclarer des pointeurs sur des objets qu'on n'utilise pas en dehors des QWidgets !!!

**koala01** · 16/09/2013, 20h08

Au moins, le code est beaucoup plus lisible, car les fonctions sont plus petites

Le problème, comme je te l'ai expliqué, c'est que, lorsque tu fais un setLayout sur un widget, cela a normalement deux effets distincts:

détruire le layout qui est utilisé par le widget avant que tu n'appelle setWidet, s'il existe
donner la propriété pleine et entière du layout au widget auquel tu le donne

De même, lorsque tu fais addWidget sur un layout, tu donne la prorpiété pleine et entière du widget au layout.

Du coup, dans le destructeur du widget, on va trouver un code proche de delete this->myLayout; et, dans destructeur du layout on va trouver un code proche de

Code :

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

1
2
3
for(int i=0;i<allWidgets.size();++i){
    delete allWidgets[i];
}

(myWidget étant un membre de QWidget qui est un pointeur sur un layout (demanière générale) et allWidgets étant une collection de pointeurs sur QWidet (de manière générale) qui est membre de QLayout).

De cette manière, on est sur que, lorsqu'un widget est détruit, le layout qui lui appartient est détruit, ce qui provoque la destruction de tous les widgets que le layout contient (provoquant la destruction de tous les layout qui appartiennent aux différents widgets ce qui provoquera...).

Bref, c'est un bel appel de delete en cascade de manière à être sur que tous les objet manipulé par un widget ou par un layout soit correctement détruits.

Sauf que, voilà.

La mémoire est séparée en deux grandes "catégories" : la pile, qui contient l'ensemble des objets créés de manière statique (comprends : sans passer par l'allocation dynamique de la mémoire), comme lorsque tu écris le code

Code :

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

int i = 145;

ou

Code :

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

QPushButton button;

ou encore

Code :

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

MainWindow w;

A chaque fois que tu appelles une fonction, si tu déclares une variable de la sorte, les dites variables sont placées dans la pile ce qui fait qu'il seront automatiquement détruits (et leurs destructeurs appelés!!!) lorsque tu sortiras de la fonction en question, et la mémoire qui avait été utilisée pour la variable sera réutilisée pour y placer une nouvelle variable lors de l'appel d'une autre fonction.

On peut donc utiliser MainWindow w; dans la fonction main, parce que, comme c'est la toute première fonction appelée, w existera tant que main s'exécute et sera automatiquement détruite (et son destructeur appelé) lorsqu'on sortira de la fonction main.

Lorsque tu déclares des membres dans MainWindow qui ne sont pas des pointeurs, ces membre font partie intégrante de la variable w et ils prennent, également, place dans la pile (dans l'ordre précis de leur déclaration), et il ne seront détruits (dans l'ordre inverse de leur déclaration) que lorsque w sera détruit.

Tout semble marcher "pour le mieux dans le meilleur des mondes", me diras-tu

Sauf que je te rappelle que le destructeur de QWidget appelle delete sur le pointeur vers le layout et que le layout appelle delete sur tous les pointeurs vers QWidget dont il(s) est (sont) propriétaire(s).

Et là, ca ne va plus du tout, parce que tu ne peux pas appeler delete sur un pointeur pointant vers un objet qui se trouve sur la pile!

Cela occasionne un undefined behaviour (ou, si tu préfères, un comportement indéfini).

Si tout "fonctionne très bien" chez toi, le fait de travailler de la sorte sur un autre système aura très certainement comme résultat le plantage de l'application lorsque tu voudras la quitter (à moins que cela ne fasse partir un missile quelconque oublié dans un silo obscure vers un pays qui est depuis longtemps devenu notre ami).

Cela nous mène tout droit à la deuxième grande catégorie de mémoire : le tas.

Chaque fois que tu fais appel à new, l'espace mémoire pour représenter l'élément est placé dans le tas, et tu deviens responsable du moment où tu voudras que l'espace mémoire en question sera libéré.

Tu ne peux appeler delete (même si c'est un composant quelconque qui le fait pour toi) que sur un pointeur vers une adresse mémoire se trouvant sur ce tas!!!

Si tu ne veux pas provoquer de comportement indéfini, et donc éviter de crouler sous les rapports de bogue du genre "plante quand on quitte l'application), tu dois impérativement utiliser l'allocation dynamique, sinon, tu fous "tout le système en l'air"

**Caramorgar** · 17/09/2013, 07h40

Quelques remarques

Qt s’en charger d'écrire a notre place les deletes dans le destructeur mais ou est l'intérêt de tout ça ?

Non, Qt n'ajoute pas les delete dans le destructeur, les objets appelle delete, mais le code des destructeurs n'est pas modifié

je ne comprends toujours pas la raison de déclarer des pointeurs sur des objets qu'on n'utilise pas en dehors des QWidgets !!!

Il est probablement qu'au final, tu n'utilises pas des QWidget, mais des classes dérivées de QWidget et que tu conserveras dans tes variables. Sans pointeur, pas de polymorphisme

Et tu devrais mieux décomposer tes classes. Par exemple, avoir une classe LeftPanel, CentralContent, ToolBar, etc. Ce qui éviterait d'avoir 100 QWidget dans ton main window

**pezimad** · 17/09/2013, 13h40

Salut Philippe,

J'ai maintenant compris très bien l'utilité de la déclaration dynamique des widgets.
Je veux apprendre à différencier entre les cas ou c'est nécessaire de déclarer les objets dynamiquement et les cas ou je peux faire la chose statiquement.

Je suppose qu'on jettent un coup d'yeux sur le prototype du constructeur si je trouve "* parent" là je dois utiliser la déclaration dynamique comme par exemple le cas du QLabel

Code :

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

1
2
 
QLabel(QWidget * parent = 0, Qt::WindowFlags f = 0)

Et si je ne trouve pas "* parent" dans le prototype du constructeur je peux dans ce cas aller sans pointeurs comme j'ai déjà fait avec QSizePolicy :

Code :

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

1
2
3
4
 
QSizePolicy sizePolicy_widget2(QSizePolicy::Preferred, QSizePolicy::Preferred);
sizePolicy_widget2.setVerticalStretch(1);
widget2->setSizePolicy(sizePolicy_widget2);

Et là Je ne sais pas si j'ai tort ou raison ?

Reprenant une citation de votre première réponse :

Envoyé par koala01

A ceci près que tu n'as peut être pas besoin de garder un pointeur sur tes layout en permanence (tu as déjà un pointeur vers les éléments de la fenêtre, pourquoi voudrais tu être en mesure d'accéder aux layouts une fois qu'ils sont placés ?), c'est cohérent avec ce que tu veux obtenir

J'ai supprimé les QLayouts de la liste des attributs de MainWindow et j'ai modifié les méthodes placeAllWidgets et placeAllLayouts pour utiliser des QLayouts déclarés dans le constructeur.

mainwindow.h :

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
27
28
29
30
31
32
33
34
35
36
37
38
39
 
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
 
#include <QMainWindow>
#include <QWidget>
#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QPushButton>
 
 
 
class MainWindow : public QMainWindow
{
    Q_OBJECT
 
public:
    MainWindow(QWidget *parent = 0);
    ~MainWindow();
 
private:
    QWidget *widget1;
    QWidget *widget2;
    QWidget *widget3;
    QWidget *widget4;
    QWidget *widget5;
    QWidget *widget6;
    QWidget *widget7;
    QWidget *widget8;
    QWidget *widget9;
 
    void setAllBackGround();
    void setAllPolicies();
    void placeAllWidgets(QVBoxLayout *, QHBoxLayout *, QVBoxLayout *, QHBoxLayout *);
    void placeAllLayouts(QVBoxLayout *, QHBoxLayout *, QVBoxLayout *, QHBoxLayout *);
 
};
 
#endif // MAINWINDOW_H

mainwindow.cpp :

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
 
#include "mainwindow.h"
 
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
{
 
    widget1 = new QWidget;
    widget2 = new QWidget;
    widget3 = new QWidget;
    widget4 = new QWidget;
    widget5 = new QWidget;
    widget6 = new QWidget;
    widget7 = new QWidget;
    widget8 = new QWidget;
    widget9 = new QWidget;
 
    QVBoxLayout * vBoxLayout1 = new QVBoxLayout;
    QHBoxLayout * hBoxLayout1 = new QHBoxLayout;
    QVBoxLayout * vBoxLayout2 = new QVBoxLayout;
    QHBoxLayout * hBoxLayout2 = new QHBoxLayout;
 
 
    setAllBackGround(); // tous les background sont définis dans cette fonction
    setAllPolicies(); // tous les setPolicy et similaires sont placé dans cette fonction
    placeAllWidgets(vBoxLayout1, hBoxLayout1, vBoxLayout2, hBoxLayout2); //place les bon widget dans le bon layout
    placeAllLayouts(vBoxLayout1, hBoxLayout1, vBoxLayout2, hBoxLayout2); // imbrique correctement les layouts
 
 
    this->setCentralWidget(widget1);
}
 
MainWindow::~MainWindow()
{
}
 
void MainWindow::setAllBackGround()
{
    widget2->setStyleSheet("background-color:#69bf3a;");
    widget3->setStyleSheet("background-color:#009fff;");
    widget4->setStyleSheet("background-color:#ffc484;");
    widget5->setStyleSheet("background-color:#db0000;");
    widget6->setStyleSheet("background-color:#f1df11;");
    widget7->setStyleSheet("background-color:#e2a4ff;");
    widget8->setStyleSheet("background-color:#ffffff;");
    widget9->setStyleSheet("background-color:#000000;");
}
 
void MainWindow::setAllPolicies()
{
    QSizePolicy sizePolicy_widget2(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget2.setVerticalStretch(1);
    widget2->setSizePolicy(sizePolicy_widget2);
 
    QSizePolicy sizePolicy_widget3(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget3.setVerticalStretch(5);
    widget3->setSizePolicy(sizePolicy_widget3);
 
    QSizePolicy sizePolicy_widget4(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget4.setHorizontalStretch(2);
    widget4->setSizePolicy(sizePolicy_widget4);
 
    QSizePolicy sizePolicy_widget5(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget5.setHorizontalStretch(4);
    widget5->setSizePolicy(sizePolicy_widget5);
 
    QSizePolicy sizePolicy_widget6(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget6.setVerticalStretch(4);
    widget6->setSizePolicy(sizePolicy_widget6);
 
    QSizePolicy sizePolicy_widget7(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget7.setVerticalStretch(1);
    widget7->setSizePolicy(sizePolicy_widget7);
 
    QSizePolicy sizePolicy_widget8(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget8.setHorizontalStretch(3);
    widget8->setSizePolicy(sizePolicy_widget8);
 
    QSizePolicy sizePolicy_widget9(QSizePolicy::Preferred, QSizePolicy::Preferred);
    sizePolicy_widget9.setHorizontalStretch(1);
    widget9->setSizePolicy(sizePolicy_widget9);
}
 
void MainWindow::placeAllWidgets(QVBoxLayout * vBoxLayout1, QHBoxLayout * hBoxLayout1, QVBoxLayout * vBoxLayout2, QHBoxLayout * hBoxLayout2)
{
    vBoxLayout1->addWidget(widget2);
    vBoxLayout1->addWidget(widget3);
    hBoxLayout1->addWidget(widget4);
    hBoxLayout1->addWidget(widget5);
    vBoxLayout2->addWidget(widget6);
    vBoxLayout2->addWidget(widget7);
    hBoxLayout2->addWidget(widget8);
    hBoxLayout2->addWidget(widget9);
}
 
void MainWindow::placeAllLayouts(QVBoxLayout * vBoxLayout1, QHBoxLayout * hBoxLayout1, QVBoxLayout * vBoxLayout2, QHBoxLayout * hBoxLayout2)
{
    widget1->setLayout(vBoxLayout1);
    widget3->setLayout(hBoxLayout1);
    widget5->setLayout(vBoxLayout2);
    widget6->setLayout(hBoxLayout2);
}

Normalement là aussi je ne suis pas obligé de détruire les pointeurs sur les QLayouts explicitement dans le destructeur de MainWindow ?

**pezimad** · 17/09/2013, 13h45

@Caramorgar. Merci j’ai documenté sur la résolution dynamique des liens est c’est un autre avantage des pointeurs

.

**pezimad** · 23/09/2013, 15h49

Bonjour,

Pour ceux qui font les recherches et qui tombent sur cette page je partage avec vous le résultat de mes recherches.
Puisque l'objectif est uniquement d'apprendre à utiliser les QLayouts j'ai mis le tout dans le constructeur.
J'ai uploadé aussi l'image du résultat de la compilation.

main.cpp :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
#include "mainwindow.h"
#include <QApplication>
 
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    w.showMaximized();
 
    return a.exec();
}

mainwindow.h :

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
 
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
 
#include <QMainWindow>
#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QWidget>
 
class MainWindow : public QMainWindow
{
    Q_OBJECT
 
public:
    MainWindow(QWidget *parent = 0);
    ~MainWindow();
 
    QWidget *w;
    QWidget *w1;
    QWidget *w2;
    QWidget *w3;
    QWidget *w4;
    QWidget *w5;
};
 
#endif // MAINWINDOW_H

mainwindow.cpp:

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
#include "mainwindow.h"
 
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
{
    w = new QWidget;
    w1 = new QWidget;
    w2 = new QWidget;
    w3 = new QWidget;
    w4 = new QWidget;
    w5 = new QWidget;
 
    QVBoxLayout *v1 = new QVBoxLayout;
    QVBoxLayout *v2 = new QVBoxLayout;
    QHBoxLayout *h1 = new QHBoxLayout;
    QHBoxLayout *h2 = new QHBoxLayout;
 
    w1->setStyleSheet("background-color:#69bf3a");
    w2->setStyleSheet("background-color:#ffc484");
    w3->setStyleSheet("background-color:#ffffff");
    w4->setStyleSheet("background-color:#000000");
    w5->setStyleSheet("background-color:#e2a4ff");
 
    v1->addWidget(w1);
    v1->addLayout(h1);
    v1->setStretch(0, 1);
    v1->setStretch(1, 3);
 
    h1->addWidget(w2);
    h1->addLayout(v2);
    h1->setStretch(0, 1);
    h1->setStretch(1, 2);
 
    v2->addLayout(h2);
    v2->addWidget(w5);
    v2->setStretch(0, 3);
    v2->setStretch(1, 1);
 
    h2->addWidget(w3);
    h2->addWidget(w4);
    h2->setStretch(0, 2);
    h2->setStretch(1, 1);
 
    w->setLayout(v1);
    setCentralWidget(w);
}
 
MainWindow::~MainWindow()
{
}

Les QLayout sont-ils vraiment une bonne pratique ? Trop de pointeurs pour déclarer les widgets ?

Discussions similaires

Partager

Partager