C++, Qt, OpenGL, CUDA

Outils d'utilisateurs

Outils du Site

Vous êtes ici: C++, Qt, OpenGL, CUDA » Les signaux et slots dans Qt 5
les_signaux_et_slots_dans_qt5

Différences

Cette page vous donne les différences entre la révision choisie et la version actuelle de la page.

Lien vers cette vue

les_signaux_et_slots_dans_qt5 [2014/10/30 00:38]
gbdivers 		les_signaux_et_slots_dans_qt5 [2022/09/06 00:43] (Version actuelle)
gbdivers
Ligne 1: Ligne 1:
-====== Les signaux et slots dans Qt 5.4 ======+====== Les signaux et slots dans Qt 5 ======
  
-===== Les signaux-slots dans Qt 4 ===== +Cet article a été transféré sur Zeste de Savoir : https://zestedesavoir.com/contenus/56/les-signaux-et-slots-dans-qt-5-4/ 
- +
-Le but des signaux-slots (qui n'est pas propre à Qt) est de créer un couplage faible entre les classes, ce qui ne nécessite pas que les classes se connaissent entre elles. +
- +
-L'idée est de créer un "lien" particulier entre deux fonctions de deux classes indépendantes, de façon à ce que lorsque l'on appelle la fonction du premier objet, la fonction du second objet est automatiquement appelée. La première fonction s'appelle "signal", la seconde "slot", le lien entre les deux s'appelle une "connexion". +
- +
-<code cpp> +
-class A { +
-public: +
-    void fonction_de_A() const {} +
-}; +
- +
-class B { +
-public: +
-    void fonction_de_B() const {} +
-}; +
- +
-int main() { +
-    A un_objet_A; +
-    B un_objet_B; +
- +
-    // création d'une connexion entre les deux fonction +
-    creer_connexion(un_objet_A, fonction_de_A, un_objet_B, fonction_de_B); +
- +
-    // lorsque l'on appelle la fonction de A, la fonction de B est  +
-    // automatiquement appelée +
-    un_objet_A.fonction_de_A(); // appelle un_objet_B.fonction_de_B() +
-} +
-</code> +
- +
-Avec ce type d'approche, vous pouvez utiliser autant de classes et de fonctions que vous souhaitez, celles-ci seront indépendantes. ''A'' n'a pas besoin de connaitre ''B'' et ''B'' n'a pas besoin de connaitre ''A''. On parle dans cette situation de "couplage faible". Nous allons voir maintenant comme cela s'utilise dans Qt, mais sachez qu'il est également possible d'utiliser cette technique avec d'autres bibliothèques (par exemple, en utilisant [[http://www.boost.org/doc/libs/1_56_0/doc/html/signals.html|Boost.Signals]]) ou en utilisant des fonctions comme argument (quelques mots-clés : std::function, functor object, lambda function, etc). +
- +
-Le système de signaux et slots de Qt est relativement simple : lorsqu'un signal est émis avec le mot clé ''emit'', tous les slots qui sont connectés à ce signal sont exécutés. Une connexion est créée en utilisant la fonction ''QObject::connect'', en donnant les arguments suivants : +
- +
-  * un pointeur vers l'objet émetteur ; +
-  * le nom du signal et la liste des types d'argument de la fonction signal (en utilisant la macro ''SIGNAL'') ; +
-  * un pointeur vers l'objet récepteur ; +
-  * le nom du slot et la liste des types d'arguments de la fonction slot (en utilisant la macro ''SLOT''). +
- +
-Il est possible de connecter plusieurs signaux à un même slot, un signal à plusieurs slots ou un signal avec un signal. +
- +
-{{ :abstract-connections.png |}} +
- +
-La correspondance entre les arguments des signaux et slots est vérifiée comme une chaîne de caractères, lors de l'exécution. Ainsi, si vous connectez un ''signal(float)'' avec une ''slot(double)'', la connexion sera refusée puisque les arguments ne correspondent pas, malgré le fait qu'un ''float'' peut être converti en ''double'' sans problème. +
- +
-<code cpp-qt> +
-QAction* a = new QAction(this); +
-QWidget* w = new QWidget(this); +
-QObject::connect( +
-    a, SIGNAL(triggered()), // connecte le signal triggered() de QAction +
-    w, SLOT(show())); // au slot show() de QWidget +
-// ce code permet donc d'afficher le QWidget lorsque l'utilisateur active la QAction +
-</code> +
- +
-Les classes de Qt fournissent de nombreux signaux et slots par défaut (la liste des signaux et slots des classes Qt est indiquée dans la documentation de Qt). Vous pouvez également créer vos propres signaux et slots dans vos classes, en respectant les règles suivantes : +
- +
-  * la classe doit dériver de ''QObject'' (directement ou indirectement) ; +
-  * il faut appeler la macro ''Q_OBJECT'' au début de la classe ; +
-  * les slots sont des fonctions classiques déclarées avec le mot-clé ''slots'' ; +
-  * les signaux sont des fonctions non implémentées déclarées avec le mot-clé ''signals''. +
- +
-Concrètement, une classe doit ressembler à quelque chose comme cela : +
- +
-<code cpp> +
-#include <QObject> +
-  +
-class UneClasse : public QObject +
-{ +
-    Q_OBJECT +
-  +
-public slots: +
-    void unSlot() { // code du slot // } +
-     +
-signals: +
-    void unSignal(); +
-}; +
-</code> +
- +
-Comme le principe est de pouvoir connecter n'importe quelle classe et et n'importe quels signaux et slots (à partir du moment où les paramètres de fonctions corresponds), vous pouvez sans problème connecter les classes Qt entre elles, avec vos propres classes ou vos propres classes entre elles. +
- +
-Remarque importante : il faut obligatoirement déclarer les classes dérivant de ''QObject'' dans un fichier ''.h'' et non dans un fichier ''.cpp'', sinon le compilateur moc de Qt ne pourra pas fonctionner. +
- +
-<note warning> +
-__ limitation __ +
- +
-signal et slot convertisse en chaine, vérification à l'exécution. Problème, erreur de frappe sera vue tardivement. Pas de type def ou de namespce +
- +
-2. pas de cast +
-</note> +
- +
-===== Les signaux et slots dans Qt 5 ===== +
- +
-Dans Qt 4, il est possible de connecter uniquement les fonctions déclarées comme signaux et slots dans la classe, comme indiqué dans les codes d'exemple précédant. Dans Qt 5, il est maintenant possible de connecter directement des pointeurs de fonctions ou d'utiliser des [[http://en.cppreference.com/w/cpp/language/lambda|fonctions lambdas]]. +
- +
-==== Connecter des pointeurs de fonctions membres ==== +
- +
-La connexion de pointeurs de fonctions est similaire à une connexion classique, en donnant un pointeur sur les objets et sur les fonctions. Les classes émettrices et réceptrices doivent dériver de QObject, mais il n'est pas nécessaire de déclarer les fonctions utilisées comme slots avec le mot clé ''slots''. +
- +
-<code cpp-qt> +
-class Sender : public QObject { +
-    Q_OBJECT +
- +
-signals: +
-    void send(int i = 0); +
-}; +
- +
-class Receiver : public QObject { +
- +
-public: +
-    void receive(int i = 0) { std::cout << "receive:" << i <send(123); +
-}; +
- +
-QObject::connect(s, &Sender::send, r, &Receiver::receive); +
-</code> +
- +
-L'avantage de cette écriture est que la compatibilité des paramètres est effectuée lors de la compilation et une conversion implicite est réalisée si nécessaire. Ainsi, il est possible de connecter un signal ''mon_signal(float)'' vers un slot ''mon_slot(float)'', mais également vers un slot ''mon_slot(double)''. +
- +
-<note warning> +
-  * Connexion et surcharge +
- +
-<code cpp> +
-QComboBox * comboBox = new QComboBox; +
-  +
-// utilisation de : void currentIndexChanged(int index) +
-connect( +
-    comboBox, +
-    static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), +
-    /* ... */); +
-  +
-// utilisation de : void currentIndexChanged(const QString & text) +
-connect( +
-    comboBox, +
-    static_cast<void (QComboBox::*)(const QString &)>(&QComboBox::currentIndexChanged), +
-    /* ... */); +
-</code> +
- +
-(Cette astuce a été donnée par [[http://www.developpez.net/forums/d1386976/c-cpp/bibliotheques/qt/qt-5-nouvelle-syntaxe-signaux-slots-distinguer-signaux-selon-leurs-arguments/#post7531279|WinJérôme sur le forum de Developpez.com]]). +
- +
-</note> +
- +
-==== Connecter des lambdas, fonctions libres et foncteurs ==== +
- +
-Il est également possible d'utiliser une fonction lambdas, fonctions libres et foncteurs comme slot dans une connexion. Par exemple, lorsque l'on souhaite connecter un signal ''QPushButton::clicked'' avec un slot ''QLabel::setText(QString)'' dans Qt 4, il n'est pas possible de créer directement la connexion. +
- +
-<code cpp-qt> +
-QPushButton* button = new QPushButton; +
-QLabel* label = new QLabel; +
-QObject::connect( +
-    button, SIGNAL(clicked()),  +
-    label, SIGNAL(setText(QString));  +
-    // erreur, les paramètres de fonctions ne correspondent pas +
-</code> +
- +
-Il faut donc écrire un intermédiaire, par exemple : +
- +
-<code cpp-qt> +
-class MyLabel : public QLabel { // ou une classe dérivée de QPushButton +
-    Q_OBJECT +
-private: +
-    QPushButton* button; +
-    QLabel* label; +
-public: +
-    MyLabel(QObject* parent = 0) : QObject(parent) { +
-        button = new QPushButton(this); +
-        label = new QLabel(this); +
-        connect(button, SIGNAL(clicked()), SIGNAL(new_slot()); // Ok +
-    } +
-private slots: +
-    void new_slot() { +
-        emit label->setText("Mon texte"); +
-    } +
-}; +
-</code> +
- +
-En utilisant les lambda, il est maintenant possible d'appeler directement : +
- +
-<code cpp-qt> +
-QPushButton* button = new QPushButton(this); +
-QLabel* label = new QLabel(this); +
-QObject::connect(button, &QPushButton::clicked, [label](){ label->setText("Mon texte"); }); +
-</code> +
- +
-Dans ce code, on capture le pointeur vers l'objet récepteur et on appelle dans la fonction lambda la fonction ''setText()''. Le résultat obtenu est identique au code précédant, mais il est possible de faire beaucoup d'autres choses dans la fonction lambda (par exemple déconnecter tous les signaux ou parcourir tous les enfants de l'objet récepteur). +
- +
-Si le compilateur utilisé ne supporte pas les //variadic template//, les signaux et slots doivent avoir moins de 6 paramètres. +
- +
-<note warning> +
-code exemple avec fonction libre et foncteur +
- +
-<code cpp> +
-class MyObject { +
-public: +
-    void operator()() { bla bla } +
-}; +
- +
-void foo() { bla bla } +
- +
- +
-MyObject object; +
-QObject::connect( +
-    sender, unSignal(), +
-    &object); +
- +
-QObject::connect( +
-    sender, unSignal(), +
-    foo); +
-</code> +
-</note> +
- +
-Dans Qt 5.2, une nouvelle syntaxe a été ajoutée, pour éviter d'avoir à récupérer un objet dans la liste de capture du lambda ou récupérer un contexte dans un environnement multithreads : +
- +
-<code cpp-qt> +
-QPushButton button; +
-QLabel label; +
-QObject::connect(&button, &QPushButton::clicked(), label, [](){ label->setText("Mon texte"); }); +
-</code> +
- +
-===== Résumé ===== +
- +
-<code cpp-qt> +
-// Qt 4 +
-QMetaObject::Connection QObject::connect( +
-    const QObject * sender, const char * signal,  +
-    const QObject * receiver, const char * method,  +
-    Qt::ConnectionType type = Qt::AutoConnection) [static] +
- +
-QMetaObject::Connection QObject::connect( +
-    const QObject * sender, const char * signal,  +
-    const char * method,  +
-    Qt::ConnectionType type = Qt::AutoConnection) const +
-     +
-// Qt 4.8 +
-QMetaObject::Connection QObject::connect( +
-    const QObject * sender, const QMetaMethod & signal,  +
-    const QObject * receiver, const QMetaMethod & method,  +
-    Qt::ConnectionType type = Qt::AutoConnection) [static] +
- +
-// Qt 5.0 +
-QMetaObject::Connection QObject::connect( +
-    const QObject * sender, PointerToMemberFunction signal,  +
-    const QObject * receiver, PointerToMemberFunction method,  +
-    Qt::ConnectionType type = Qt::AutoConnection) [static] +
- +
-QMetaObject::Connection QObject::connect( +
-    const QObject * sender, PointerToMemberFunction signal,  +
-    Functor functor) [static] +
- +
-// Qt 5.2 +
-QMetaObject::Connection QObject::connect( +
-    const QObject * sender, PointerToMemberFunction signal,  +
-    const QObject * context, Functor functor,  +
-    Qt::ConnectionType type = Qt::AutoConnection) [static] +
-</code> +
- +
-Remarque : toutes ces fonctions sont ''static'', sauf la seconde. +
- +
-===== Fonctionnement interne des connexions dans Qt ===== +
- +
-Lorsque l'on utilise la syntaxe pour créer une connexion dans Qt 4, la compatibilité entre les paramètres de fonction est réalisée via une analyse textuelle. Qu'est-ce que cela signifie en pratique. +
- +
-Lorsque l'on écrit : ''SIGNAL(un_signal(QString))'', il ne s'agit pas en fait de la déclaration d'une fonction, mais d'une création de chaîne de caractères contenant ''"un_signal(QString)"''. +
- +
- +
- +
- +
-  * meta objet et conservation des connexions en interne +
-    * les signaux et slots en mutlithreads +
- +
-===== Conclusion ===== +
- +
-Vous pouvez télécharger un projet d'exemple montrant ces nouvelles fonctionnalités en action : [[https://github.com/GuillaumeBelz/signaux-slots|la page de téléchargement sur GitHub]]. +
- +
-Les images et codes d'exemple sont issus en partie de la documentation de Qt5 disponible à cette page : [[http://doc-snapshot.qt-project.org/qt5-dev/signalsandslots.html|Signals & Slots]]. +
- +
-==== Mises à jour ==== +
- +
-  * 12/09/2014 : correction de la syntaxe des lambdas, suite à une remarque de WinJérôme +
-  * 27/10/2014 :  +
-    * mise à jour pour Qt 5.4 +
-    * suppression de la partie sur le couplage (cela fera partie d'un article plus généraliste sur la communication inter-classes) +
-    * ajout sur les classes QSignalMapper, QSignalBlocker +
-    * ajout de la partie sur le fonctionnement interne des connexions +
- +
-==== Sources ==== +
- +
-  * [[http://doc-snapshot.qt-project.org/qt5-dev/signalsandslots.html|Signals & Slots]] +
-  * [[http://doc-snapshot.qt-project.org/qt5-dev/signalsandslots-syntaxes.html|Differences between String-Based and Functor-Based Connections]] +
-  * La documentation des classes [[http://doc-snapshot.qt-project.org/qt5-dev/qsignalmapper.html|QSignalMapper]], [[http://doc-snapshot.qt-project.org/qt5-dev/qsignalblocker.html|QSignalBlocker]] et [[http://doc-snapshot.qt-project.org/qt5-dev/qsignalspy.html|QSignalSpy]] +
-  * [[https://www.youtube.com/watch?v=pwNd8gq6PZY|Qt Developer Days 2013 - Olivier Goffart - Signals and Slots in Qt 5]] +
-  * [[http://qt.developpez.com/tutoriels/qt-5/woboq-signaux-slots/|Les signaux et slots avec Qt 5]] +
-  * http://woboq.com/blog/how-qt-signals-slots-work-part2-qt5.html +
-  * http://pokecraft.first-world.info/wiki/Benchmark_for_conception +
- +
-{{tag> Qt}}+
les_signaux_et_slots_dans_qt5.1414625935.txt.gz · Dernière modification: 2014/10/30 00:38 par gbdivers

Outils de la Page

Sauf mention contraire, le contenu de ce wiki est placé sous la licence suivante : CC Attribution-Noncommercial-Share Alike 3.0 Unported
CC Attribution-Noncommercial-Share Alike 3.0 Unported Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki