Échange de variables entre deux fenêtres

Bonjour,

A partir d'une QMainWindow, je construis un QDialog qui prendra en paramètre un pointeur sur une classe lambda construite également dans la fenêtre principale :

maboitedialogue.cpp :

Code:

---

MaBoiteDialogue::MaBoiteDialogue(Lambda* pLambda, QWidget *parent) : QDialog(parent){...}

---

Cela me permet de transférer simplement des variables de la fenêtre principale vers ma boîte de dialogue.

En paramétrant les SIGNAL/SLOT des uns et des autres, je récupère les variables de ma boîte de dialogue pour les transférer cette fois-ci dans l'autre sens, à ma fenêtre principale.

mainwindow.cpp :

Code:

---

1 2 3

maBoiteDialogue = new MaBoiteDialogue(pLambda, this); connect(ui->caseBoiteDialogue, SIGNAL(toggled(bool)), this, SLOT(AfficherBoiteDialogue(bool))); connect(maBoiteDialogue, SIGNAL(TransmettreInfo(int, QString, QString)),this, SLOT(RecevoirInfo(int, QString, QString)));

---

Mon souci est que le transfert marche bien dans un sens (fenêtre principale vers boîte de dialogue), bien dans l'autre (boîte de dialogue vers fenêtre principale), mais pas dans les 2 sens en même temps !

La faute à la fonction appelée ci-dessus :

Code:

---

1 2 3 4

void MainWindow::AfficherBoiteDialogue(bool ok){ if (ok) maBoiteDialogue->exec(); }

---

Car elle n'arrive pas à construire la boîte de dialogue avec un pLambda actualisé par les actions de la fenêtre principale... D'où ma question : comment exécuter l'ouverture de la boîte de dialogue en récupérant le pointeur sur la classe lambda (pLambda) à cet instant là ?

Merci pour vos lumières éclairantes, parce que je suis dans l'obscurité la plus totale :koi:

Bonjour,

Si la boite de dialogue est crée par la fenêtre principale, pourquoi ne pas utiliser un simple getter ?

Citation:

---

Envoyé par LittleWhite

Bonjour,

Si la boite de dialogue est crée par la fenêtre principale, pourquoi ne pas utiliser un simple getter ?

---

Bonjour,

Merci pour cette piste; néanmoins ma classe MainWindow n'hérite pas de ma classe Lambda (voir diagramme joint), celle-ci y est simplement instanciée; je ne peux donc pas y faire appel au getter :calim2:

Le diagramme ne correspond pas à ce que je comprends du premier message. La classe Lambda est créée/gérée par qui ? La boite de dialogue hérite réellement de cette classe Lambda ? (il serait absurde de lui passer un pointeur en paramètre du coup)

De ce que je comprends du premier message. MainWindow gère (comprendre, crée, détruit, et affiche au besoin) la boite de dialogue. Je suppose que MainWindow crée/détruit également l'instance de Lambda, et agit sur les données de Lambda.

Si les durées de vie de l'instance de Lambda et de l'instance de MaBoiteDeDialogue sont identiques, alors la boite de dialogue doit simplement conserver un pointeur (ou mieux une référence) vers l'objet lambda et transmettre les données directement par des fonctions de cet objet. Dans ce cas là inutile d'utiliser les signaux/slots pour transmettre les données. Et la boite de dialogue a en permanence accès à lambda pour lui faire faire des traitements.

Citation:

---

Envoyé par ymoreau

La classe Lambda est créée/gérée par qui ? La boite de dialogue hérite réellement de cette classe Lambda ? (il serait absurde de lui passer un pointeur en paramètre du coup)

---

Une variable de type Lambda est créée dans MainWindow (par l'intermédiaire d'un pointeur) et y est modifiée. C'est de ces modifications dont j'ai besoin lorsque je crée MaBoiteDialogue; et cette dernière doit à son tour modifier la même variable de type Lambda (pLambda).

Citation:

---

Envoyé par ymoreau

De ce que je comprends du premier message. MainWindow gère (comprendre, crée, détruit, et affiche au besoin) la boite de dialogue. Je suppose que MainWindow crée/détruit également l'instance de Lambda, et agit sur les données de Lambda.

---

oui, c'est par une case à cocher de la MainWindow qu'on crée MaBoiteDialogue, en lui transmettant pLambda par son constructeur.

Citation:

---

Envoyé par ymoreau

Si les durées de vie de l'instance de Lambda et de l'instance de MaBoiteDeDialogue sont identiques, alors la boite de dialogue doit simplement conserver un pointeur (ou mieux une référence) vers l'objet lambda et transmettre les données directement par des fonctions de cet objet.

---

Les durées de vie sont différente : l'instance de Lambda apparaît à la construction de la MainWindow, est modifiée successivement par cette dernière et par MaBoiteDialogue et n'est détruite qu'avec la MainWindow.

Et c'est bien tout ma difficulté : construire MaBoiteDialogue avec l'instance modifiée de Lambda tout en ayant des 'connect' permanent entre MainWindoW et MaBoiteDialogue : dans le premier cas je construis ma fenêtre dans la fonction AfficherBoiteDialogue(), dans le second je dois la construire dans le constructeur de MainWindow. Mais l'un est exclusif de l'autre...:cry: sauf à transmettre pLambda modifié à MaBoiteDialogue, ce que je n'arrive pas à faire autrement que par son constructeur.

Je comprends peut être de travers, mais les durées de vie semblent justement être exactement les mêmes entre l'objet lambda et la boite de dialogue (puisqu'elle est connectée dés le constructeur de mainwindow). D'après le code fourni, la boite de dialogue n'est pas construite au moment de l'affichage mais appartient à la MainWindow au même titre que lambda.

Donc, il n'est pas nécessaire de passer pLambda à chaque affichage de la boite de dialogue, car l'objet lambda ne change pas, son adresse non plus, son pointeur passé en paramètre à la boite de dialogue reste valide tout le long de l'exécution de MainWindow.

Cela dit, il est assez fréquent de ne créer une boite de dialogue qu'au moment où on veut l'afficher, surtout si elle est modale (comme ici).
Ce qui donnerait :

Code:

---

1 2 3 4 5 6

void MainWindow::AfficherBoiteDialogue(bool ok) { if (ok) { MaBoiteDialogue maBoiteDialogue(pLambda, this); maBoiteDialogue.exec(); } }

---

L'objet boite de dialogue est local à cette fonction, il n'est créé en mémoire que si l'on a effectivement besoin de l'afficher (mais sera créé à chaque appel, c'est un choix à réfléchir).

Pour continuer avec ta solution de signal/slot tu pourrais faire le connect au même endroit, juste après avoir créé l'objet maBoiteDialogue. Cependant comme je l'ai dit plus haut, ça ne me semble pas une bonne idée :
Je suppose que la MainWindow va appeler des setters/getters de lambda, et que la boite de dialogue fera la même chose. Autant appeler directement les fonctions sur pLambda plutôt que de passer par un signal/slot entre MainWindow et MaBoiteDialogue, puisque chaque objet a directement accès à lambda.

Citation:

---

Envoyé par ymoreau

Je comprends peut être de travers, mais les durées de vie semblent justement être exactement les mêmes entre l'objet lambda et la boite de dialogue (puisqu'elle est connectée dés le constructeur de mainwindow). D'après le code fourni, la boite de dialogue n'est pas construite au moment de l'affichage mais appartient à la MainWindow au même titre que lambda.

---

Oui c'est exact, je raisonnais mal (en terme d'affichage et non de construction...)

Citation:

---

Envoyé par ymoreau

Donc, il n'est pas nécessaire de passer pLambda à chaque affichage de la boite de dialogue, car l'objet lambda ne change pas, son adresse non plus, son pointeur passé en paramètre à la boite de dialogue reste valide tout le long de l'exécution de MainWindow.

---

C'est que du bon sens ! (mais quand on part en quenouille, il est difficile de se raccrocher à une once d'intelligence)

Citation:

---

Envoyé par ymoreau

Cela dit, il est assez fréquent de ne créer une boite de dialogue qu'au moment où on veut l'afficher, surtout si elle est modale (comme ici).
Ce qui donnerait :

Code:

---

1 2 3 4 5 6

void MainWindow::AfficherBoiteDialogue(bool ok) { if (ok) { MaBoiteDialogue maBoiteDialogue(pLambda, this); maBoiteDialogue.exec(); } }

---

L'objet boite de dialogue est local à cette fonction, il n'est créé en mémoire que si l'on a effectivement besoin de l'afficher (mais sera créé à chaque appel, c'est un choix à réfléchir).

---

C'est un choix que j'avais testé mais qui pose effectivement beaucoup d'autres problèmes...

Citation:

---

Envoyé par ymoreau

Pour continuer avec ta solution de signal/slot tu pourrais faire le connect au même endroit, juste après avoir créé l'objet maBoiteDialogue. Cependant comme je l'ai dit plus haut, ça ne me semble pas une bonne idée :
Je suppose que la MainWindow va appeler des setters/getters de lambda, et que la boite de dialogue fera la même chose. Autant appeler directement les fonctions sur pLambda plutôt que de passer par un signal/slot entre MainWindow et MaBoiteDialogue, puisque chaque objet a directement accès à lambda.

---

Je retiens ta première solution, qui a l'avantage d'être fort propre; je teste tout ça et poste la solution (si j'y arrive...)

Merci pour ce recadrage bien utile 8O

Citation:

---

Envoyé par ymoreau

l'objet lambda ne change pas, son adresse non plus, son pointeur passé en paramètre à la boite de dialogue reste valide tout le long de l'exécution de MainWindow.

---

En théorie j'ai tout bien compris (enfin je crois...), mais il me reste une dernière question pratique : après avoir passé le pointeur pLambda au constructeur de MaBoiteDialogue (lors de l'ouverture de MainWindow), comment transférer ce pointeur aux fonctions qui vont gérer les évènements de MaBoiteDialogue ?

Là je coince...

En POO quand on a besoin d'une variable ou d'un objet à plusieurs endroit dans une classe, on en fait un attribut de la classe. Dans le cas d'un pointeur c'est un peu risqué car dans une fonction on n'est à priori jamais certain à 100% que le pointeur a bien été initialisé avant.
Dans ton cas, il est en paramètre du constructeur et initialisé directement dans le constructeur donc ça ne devrait jamais poser problème.

Mais pour se faciliter la vie il est largement préférable d'utiliser les références plutôt que les pointeurs ! Il faut juste penser à faire une "vraie" initialisation de l'attribut dans le constructeur car une référence doit être initialisée et non pas affectée. Là dessus les cours de C++ fourniront tous les détails.

Citation:

---

Envoyé par ymoreau

En POO quand on a besoin d'une variable ou d'un objet à plusieurs endroit dans une classe, on en fait un attribut de la classe.

---

Merci, je n'avais pas fait le lien; à trop phosphorer on en oublie l'essentiel...

Merci encore à Yoann pour sa patience et sa pédagogie; tout fonctionne à merveille et ci-dessous la soluce détaillée (où effectivement aucun reparamétrage de SIGNAL/SLOT n'est nécessaire...)

mainwindow.h

Code:

---

1 2 3 4 5 6 7 8 9

class MainWindow : public QMainWindow { Lambda *pLambda; MaBoiteDialogue *maBoiteDialogue;   public slots: void AfficherBoiteDialogue(bool); };

---

mainwindow.cpp

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent) { maBoiteDialogue = new MaBoiteDialogue(pLambda, this);   connect(ui->caseACocher, SIGNAL(toggled(bool)), this, SLOT(AfficherBoiteDialogue(bool))); }   void MainWindow::AfficherBoiteDialogue(bool ok) { if (ok){ maBoiteDialogue->pLambdaBis = pLambda; maBoiteDialogue->show(); } }

---

On a donc accès dans la boîte de dialogue aux valeurs des attributs de la classe Lambda, modifiés par des évènements dans la fenêtre principale.

maboitedialogue.h

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

class MaBoiteDialogue : public QDialog, public Lambda { Q_OBJECT   public: explicit MaBoiteDialogue(Lambda*, QWidget *parent = 0); ~MaBoiteDialogue(); Lambda *pLambdaBis;   public slots: void ValiderBoiteDialogue(void); };

---

maboitedialogue.cpp

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

MaBoiteDialogue::MaBoiteDialogue(Lambda* pLambda, QWidget *parent) : QDialog(parent) { pLambdaBis = pLambda;   connect(ui->ok, SIGNAL(clicked()), SLOT(ValiderBoiteDialogue())); }   void MaBoiteDialogue::ValiderBoiteDialogue(void) { pLambdaBis->SetInt(ui->... .toInt()); pLambdaBis->SetQString1(ui->...->currentText()); pLambdaBis->SetQString2(ui->...->currentText());   this->close(); }

---

Ensuite, dans une fonction de MainWindow, on peut récupérer les valeurs de la boîte de dialogue avec pLambda = maBoiteDialogue->pLambdaBis et le tour est joué :ccool:

Très bon week-end à tous

Je crains que tu aies mal compris le fonctionnement des objets, de la mémoire et des pointeurs. C'est un principe pas évident mais qui est fondamental, cela vaudrait sûrement la peine de prendre le temps de lire des cours détaillés si tu es amené à faire encore du C++ régulièrement.

En très bref : un pointeur est l'adresse d'un objet en mémoire, l'objet est créé avec new qui te renvoie son adresse. Cette adresse ne change pas tant que tu ne détruis pas l'objet.
Quand tu appelles des fonctions sur pLambdaBis tu les appelles sur l'objet situé à l'adresse mémoire du pointeur pLambdaBis, qui est la même que le pLambda de la mainwindow (puisque tu as fait pLambdaBis = pLambda; dans le constructeur). Il ne sert à rien de refaire :

Code:

---

maBoiteDialogue->pLambdaBis = pLambda;

---

ni

Code:

---

pLambda = maBoiteDialogue->pLambdaBis

---

Quand tu auras bien compris comment ça fonctionne, intéresse toi aux références, qui feront exactement la même chose mais en plus simple (et plus sûr). Bonne lecture ! ;)

Citation:

---

Envoyé par ymoreau

Quand tu appelles des fonctions sur pLambdaBis tu les appelles sur l'objet situé à l'adresse mémoire du pointeur pLambdaBis, qui est la même que le pLambda de la mainwindow (puisque tu as fait pLambdaBis = pLambda; dans le constructeur). Il ne sert à rien de refaire :

Code:

---

maBoiteDialogue->pLambdaBis = pLambda;

---

ni

Code:

---

pLambda = maBoiteDialogue->pLambdaBis

---

---

Je m'étais bien dit la même chose... mais j'avais pas osé ! pourtant ça marche...

Merci encore.