Qt signaux et des slots dans les différentes classes

J'ai une classe X avec une fente, et une classe Y avec un signal. Je suis la mise en place de la connexion à partir de la classe de X, et a créé une méthode publique de la classe Y pour émettre le signal à partir de la classe X (je ne suis pas sûr que cette étape était nécessaire).

Alors, si j'appelle cette méthode de la classe X, le signal est émis, et que le logement est exécutée. Mais si j'émet le signal de la classe Y, logement n'est jamais exécutée et je ne comprends pas pourquoi.

Je tiens également à la classe de Y?

De ce pseudo-code tente d'expliquer ce que je veux:

class X  : public QWidget {
    Q_OBJECT

X(){
    connect(Y::getInstance(), SIGNAL(updateSignal(int)), this, SLOT(updateStatus(int)));
    Y::getInstance().emitSignal(someValue); //Works
}

public slots:
    void updateStatus(int value);

}

class Y : public QObject {

Q_OBJECT

Y(){

}

public:
    Y getInstance();
    void emitSignal(int value) { 
        emit updateSignal(value);
    }


signal:
    void updateSignal(int value);
}

class Z : public Y {
Z(){

}

init(){
 emitSignal(someValue); //Doesn't work
}
}
pouvez-vous donner un code? je ne peux pas comprendre exactement ce que vous essayez de dire
Non, vous devez établir une connexion qu'une seule fois. Veuillez poster une partie de votre code.
C'est du code très complexe, donc je vais poster quelques pseudo pour expliquer la question de mieux
Eh bien à partir de votre simplifié de code, il semble que vous essayez d'émettre le signal dans le constructeur, où la connexion n'est pas encore fait. Peut-être juste une simplification de l'artefact.
Une instance de l'objet X exister au moment où la fonction init() est appelée? (Je ne vois pas X instancié n'importe où dans votre pseudo/simplifié le code).

OriginalL'auteur Roman Rdgz | 2012-06-05

  1. 4

    Rappelez-vous que les connexions ne sont pas entre classes, mais entre instances. Si vous émettez un signal et s'attendre connecté fentes pour être appelé, il doit être émis sur une instance sur laquelle la connexion a été effectuée. C'est votre problème.

    En supposant que Y est une Singleton:

    Si vous ne connect( Y::getInstance(), ... )

    et Y::getInstance() ne new Y() à un certain point, alors le constructeur de Y est appelé avant que la connexion est établie. Comme ça, le signal sera émis, mais le logement ne sera pas de l'écouter encore.

    En dehors de cela, il serait préférable de faire une des choses suivantes, bien que vous pourriez ne pas émettre le signal dans le constructeur de Y avec ces approches:

    • Utiliser une troisième classe Z qui sait à la fois X et Y, et de faire le lien
    • L'Injection De Dépendance. Cela signifie que X devient une instance de Y dans son constructeur:

    Exemple pour une Injection de Dépendance Constructeur:

    X::X( Y* const otherClass )
{
    connect( otherClass, SIGNAL( ... ), this, SLOT( ... )
}

    OriginalL'auteur Tim Meyer

  2. 3

    Son simple. Veuillez voir exemple ci-dessous.

    Si vous voulez écrire des signaux & les fentes dans votre propre classe, vous devez répondre à deux conditions...

    1. Your class must inherit from QObject class or any class derived from QObject.

    2. The Q_OBJECT macro must appear in a private section in your class.

    /* Sender.h */

#ifndef SENDER_H
#define SENDER_H

#include <QObject>

class Sender : public QObject
{
    Q_OBJECT
public:
    explicit Sender(QObject *parent = 0);    
    void fireSignal();

signals:
    void foo(const QString& arg);
};

#endif //SENDER_H


/* Sender.cpp*/


#include "Sender.h"

Sender::Sender(QObject *parent) :
    QObject(parent)
{
}


void Sender::fireSignal()
{
    emit foo("This a message sender is sending to receiver.");
}

    Maintenant du récepteur de code ci-dessous

    /* Receiver.h */

#ifndef RECEIVER_H
#define RECEIVER_H

#include <QObject>

class Receiver : public QObject
{
    Q_OBJECT
public:
    explicit Receiver(QObject *parent = 0);

public slots:
    void bar(const QString& arg);

};

#endif //RECEIVER_H

/* Receiver.cpp */

#include "Receiver.h"
#include <iostream>

Receiver::Receiver(QObject *parent) :
    QObject(parent)
{
}


void Receiver::bar(const QString &arg)
{
    std::cout << arg.toStdString();
}

    Maintenant main.cpp code

    #include <QtCore/QCoreApplication>
#include "Sender.h"
#include "Receiver.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    Sender sender;
    Receiver receiver;

    QObject::connect(&sender, SIGNAL(foo(QString)), &receiver, SLOT(bar(QString)));

    sender.fireSignal();

    return a.exec();
}

    .

    Enfin, si vous souhaitez utiliser une autre syntaxe pour la méthode de connexion. Veuillez utiliser le dessous des lignes

    QObject::connect(&sender,&Sender::foo,&receiver,&Receiver::bar);

    Espère que cela vous a aidé.
    Grâce

    OriginalL'auteur loyola

  3. 0

    Vous sont émettant des signaux à partir du constructeur. À l'époque Y::getInstance() n'a pas de sens en FONCTION DE CE fragment de code.

    C'est juste une simplification. Je fais la Y instance de droit. Si non, je ne dirais pas emitSignal œuvres de X
    Oui. vous appelez Y::getInstance().emitSignal(someValue); de X. Il fonctionne, car à cette époque, vous avez un objet de Y. Mais vous ne pouvez pas le faire à partir de l'axe du constructeur.
    Ok, il n'est pas le cas chez le constructeur, ça se passe à l'autre partie de Y code. De toute façon je ne vois pas pourquoi je ne peux pas appeler un Y de la méthode à partir de Y du constructeur
    Ah je vois que vous êtes en héritant de Y, etc... connect() fonctionne sur les cas pas sur les classes... peut-être que l'instance se foiré quelque part dans la chaîne d'héritage. Vous pouvez même suivre l'emit() dans un débogueur pour voir ce qui se passe avec une version de débogage de l'intervalle Qt.
    Aussi, connect() retourne true ou false. Si vous vous connectez à ceux que vous trouverez peut assez vite s'il ne parvient pas 🙂 émettre() en revanche n'a pas d'erreur si il n'y a pas de slot connecté à son signal.

    OriginalL'auteur shan