QMessageBox qui plante un programme

Bonjour,

J'ai un problème que je ne comprends pas, et le debug ne m'apporte pas d'information.
Que je suis capable de comprendre tout du moins.

En fait, j'ai une fenêtre principale qui va afficher plusieurs autres fenêtres sous forme d'onglet.
Dans le constructeur de la fenêtre principale je créé les sous-fenêtres et lors de la création de ces sous fenêtres je charge des données contenues dans des fichiers XML.

A un moment, je me retrouve donc dans une classe, sans lien direct avec l'affichage, qui a la charge de lire les fichiers XML. Je voudrais pouvoir afficher un message pour prévenir l'utilisateur lorsqu'une erreur survient.
J'ai donc ajouter un QMessageBox::critical(...) dans ma méthode (statique d'ailleurs).

Le problème c'est que si la boîte de dialogue s'affiche le programme plante arrivé à l'affichage de la fenêtre principale (fenetrePrincipale.showMaximized(); ).

Le debuger me dit juste qu'il y a une SIGSEV à cette ligne mais je n'arrive pas à savoir pourquoi.
Quand je regarde mes objets juste avant l'affichage de la fenêtre principale, ils sont bien construits.

Lorsque j'enlève la boîte de dialogue, tout fonctionne bien.

Je suis un peut perdu, donc je ne donne pas de code ou quoi que ce soit car il y en a beaucoup.
Si vous avez une idée de l'endroit d'où sa pourrait venir, ou désirez des compléments d'informations : n'hésitez pas.

Merci.

Bonjour,

Tu peux au moins donner la déclaration de fenetrePrincipale sinon ça va être difficile de t'aider.

Sans problème ^^

Code:

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
#ifndef FENETRE_PRINCIPALE_H
#define FENETRE_PRINCIPALE_H
 
#include "Demande.h"
 
#include <QtGui/QMainWindow>
#include <QtGui/QMdiSubWindow>
#include <QtGui/QMenu>
#include <QtGui/QAction>
 
#include <QModelIndex>
 
#include <QtCore/QSignalMapper>
 
#include <QLabel>
 
class SubWindow;
class FenetreListeDemandes;
class FenetreDemande;
class FenetreEditListeComptes;
 
class FenetrePrincipale : public QMainWindow
{
	Q_OBJECT
 
	public:
		FenetrePrincipale(QWidget *parent = 0);
 
	public slots :
		void ouvrirSousFenetre(QObject* objet);
		void ouvrirDemande(const Demande demande = Demande());
 
	private :
		QSignalMapper* signalMapper;
 
		QMenu*	menuFichier;
			QAction*	actionNouvelleDemande;
			QAction*	actionQuitter;
		QMenu*	menuFenetre;
			QAction*	actionFenetreEditListeComptesSW;
 
		QMdiArea *centralWidget;
			SubWindow* fenetreListeDemandeSW;
				FenetreListeDemandes* fenetreListeDemandes;
			QMdiSubWindow* fenetreDemandeSW;
				FenetreDemande* fenetreDemande;
			SubWindow* fenetreEditListeComptesSW;
				FenetreEditListeComptes* fenetreEditListeComptes;
};
 
#endif // FENETRE_PRINCIPALE_H

La classe SubWindow est juste un QSubWindow qui ne peut pas être fermé.
C'est FenetreListeDemande qui va devoir afficher une liste de demande qui va lire le fichier XML contenant toutes les demandes.
Pour une demande j'ai un compte que je récupère dans un fichier XML contenant la liste des comptes.

Code:

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
#ifndef FENETRELISTEDEMANDES_H
#define FENETRELISTEDEMANDES_H
 
#include <QtGui/QWidget>
#include <QtGui/QVBoxLayout>
#include <QtGui/QComboBox>
#include <QtGui/QListView>
#include <QtGui/QPushButton>
#include <QDate>
 
class FenetrePrincipale;
class VueListeDemandes;
 
class FenetreListeDemandes : public QWidget
{
	Q_OBJECT
 
    public :
		FenetreListeDemandes(FenetrePrincipale* fenetrePrincipale, QWidget* parent = 0);
		virtual ~FenetreListeDemandes();
 
    private :
		FenetrePrincipale*	fenetrePrincipale;
 
		QVBoxLayout*		globalVBL;
		QComboBox*				anneeCB;
		VueListeDemandes*		demandesVLD;
		QPushButton*			quitterPB;
		QPushButton*			nouveauPB;
 
		void dessinerFenetre();
		void creerConnections();
 
		void chargerAnnees();
 
	public slots :
		void majListeDemandes(QString anneeQString = QString::number(QDate::currentDate().year()));
};
 
#endif // FENETRELISTEDEMANDES_H

Dans le constructeur je vais charger la liste des demandes depuis une méthode statique de la classe Demande

Code:

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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
#ifndef DEMANDE_H
#define DEMANDE_H
 
 
#include <QDate>
#include <QString>
#include <QStringList>
#include <QPair>
#include <QMap>
#include <QtCore/QDir>
 
class ListeDemandes;
class ListeComptes;
class Compte;
class DomDocument;
 
class Demande
{
	public :
		static const QDir		CHEMIN_DONNEES;
		static ListeDemandes&	getListeDemandes(int);
 
		Demande();
		Demande(const Demande& demande);
		~Demande();
 
		void ajouterNumeroCoulee(QString);
		void ajouterNuance(QString);
		void ajouterCodeAcier(QString);
		void ajouterSousTraitant(QString);
		void ajouterDocumentLie(QString, QString);
 
		bool isEmpty() const;
 
		bool saveToPdf(QString cheminFichierSortie = QString()) const;
 
		void setAnnee(int);
		void setNumero(int);
		void setDemandeur(QString);
		void setClientAM(QString);
		void setClientFinal(QString);
		void setProduit(QString);
		void setDescriptionDemande(QString);
		void setListeNumeroCoulee(QStringList);
		void setListeNuance(QStringList);
		void setListeCodeAcier(QStringList);
		void setResponsable(QString);
		void setTechnicien(QString);
		void setDateReceptionEchantillon(QDate);
		void setDateMiseEnMain(QDate*);
		void setDelaiPremiereApproche(QString);
		void setReportDelaiNegocie(QString);
		void setListeSousTraitant(QStringList);
		void setNatureTravaux(QString);
		void setCompte(Compte*);
		void setWorkPackage(QString);
		void setChargeTechnicien(float);
		void setChargeIngenieur(float);
		void setDevis(float);
		void setNumeroRapport(QString);
		void setDateRapportFinal(QDate*);
		void setCommentaires(QString);
		void setListeDocumentsLies(QList< QPair<QString, QString> >);
		void setNomFichierJoint(QString);
 
		const QString&			getCheminFichierXml() const;
		int						getAnnee() const;
		int						getNumero() const;
		const QString&			getDemandeur() const;
		const QString&			getClientAM() const;
		const QString&			getClientFinal() const;
		const QString&			getProduit() const;
		const QString&			getDescriptionDemande() const;
		const QStringList&		getListeNumeroCoulee() const;
		const QStringList&		getListeNuance() const;
		const QStringList&		getListeCodeAcier() const;
		const QString&			getResponsable() const;
		const QString&			getTechnicien() const;
		const QDate&			getDateReceptionEchantillon() const;
		QDate*					getDateMiseEnMain() const;
		const QString&			getDelaiPremiereApproche() const;
		const QString&			getReportDelaiNegocie() const;
		const QStringList&		getListeSousTraitant() const;
		const QString&			getNatureTravaux() const;
		Compte*					getCompte() const;
		const QString&			getWorkPackage() const;
		float					getChargeTechnicien() const;
		float					getChargeIngenieur() const;
		float					getDevis() const;
		const QString&			getNumeroRapport() const;
		QDate*					getDateRapportFinal() const;
		const QString&			getCommentaires() const;
		const QList< QPair<QString, QString> >& getListeDocumentsLies() const;
		const QString&			getNomFichierJoint() const;
 
		QString toString() const;
		DomDocument toXml() const;
 
	private :
		static QMap<int, ListeDemandes> listeDemandes;
 
		static Demande chargerDemande(QString);
		static ListeDemandes chargerDemandes(int);
 
		QString			cheminFichierXml;
		int				annee;
		int				numero;
		QString			demandeur;
		QString			clientAM;
		QString			clientFinal;
		QString			produit;
		QString			descriptionDemande;
		QStringList		listeNumeroCoulee;
		QStringList		listeNuance;
		QStringList		listeCodeAcier;
		QString			responsable;
		QString			technicien;
		QDate			dateReceptionEchantillon;
		QDate*			dateMiseEnMain;
		QString			delaiPremiereApproche;
		QString			reportDelaiNegocie;
		QStringList		listeSousTraitant;
		QString			natureTravaux;
		//Compte*			compte;
		QString			codeCompte;
		QString			workPackage;
		float			chargeTechnicien;
		float			chargeIngenieur;
		float			devis;
		QString			numeroRapport;
		QDate*			dateRapportFinal;
		QString			commentaires;
		QList< QPair<QString, QString> > listeDocumentsLies;
		QString			nomFichierJoint;
};
 
#include <QVariant>
Q_DECLARE_METATYPE(Demande)
 
#endif // DEMANDE_H

Plus simplement (c'était la juste déclaration de l'objet fenetrePrincipale que je voulais ;)) : tu l'as déclaré en pointeur et ensuite tu fais fenetrePrincipale.showMaximized(); ? Normal que ça plante alors.

Ensuite tu donnes exactement le même nom à ton paramètre constructeur et à une variable membre... (fenetrePrincipale justement). Ce n'est pas une bonne idée à mon avis :)

Oui, alors non ^^
J'ai pas été très clair.
Le pointeur de type FenetrePrincipale qui se trouve dans la classe FenetreListeDemandes n'est utile que pour créer des connections entre les deux fenêtres.

J'avais fait ainsi plutôt que de passer un paramètre à ma méthode creerConnections().
Je viens de le changer et ça ne résoud pas le problème, ce qui est logique.

De plus, c'est bien w.showMaximized(); car dans le main.cpp ma fenêtre principale n'est pas un pointeur mais un objet de type FenetrePrincipale. C'est cet objet qui créé la FenetreListeDemande et lui passe en paramètre du constructeur le pointeur this.

Concernant les noms, il suffit de se rappeler que dans une méthode ayant un paramètre de même nom qu'un attribut on accède par défaut au paramètre. Il faut utiliser le pointeur this pour accéder à l'attribut.

Mais merci quand même.

Au passage, je rappel que sans rien changer au code, à part la suppression du QMessageBox, tout marche sans problème.
Je me demande donc si ce comportement étrange ne viens pas du fait que le boîte de dialogue créée dans une partie de code qui est appelé par un constructeur d'une QMainWidow...
Il me semblait avoir compris que du moment que l'on ne donne pas de parent à une boîte de dialogue, elle est totalement indépendante du reste mais je peux me tromper.