c++ - sucursales - valor del tag

¿Las señales de Qt pueden devolver un valor?

Question

Boost.Signals permite varias estrategias de uso de los valores de retorno de las ranuras para formar el valor de retorno de la señal. Por ejemplo, sumarlos, formar un vector partir de ellos o devolver el último.

La sabiduría común (expresada en la documentación de Qt [EDIT: así como algunas respuestas a esta pregunta ] ) es que tal cosa no es posible con las señales de Qt.

Sin embargo, cuando ejecuto el moc en la siguiente definición de clase:

class Object : public QObject {
    Q_OBJECT
public:
    explicit Object( QObject * parent=0 )
        : QObject( parent ) {}

public Q_SLOTS:
    void voidSlot();
    int intSlot();

Q_SIGNALS:
    void voidSignal();
    int intSignal();
};

No solo no se queja de la señal con el tipo de devolución no nulo, sino que parece implementarla activamente de tal manera que permita que pase un valor de retorno:

// SIGNAL 1
int Object::intSignal()
{
    int _t0;
    void *_a[] = { const_cast<void*>(reinterpret_cast<const void*>(&_t0)) };
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
    return _t0;
}

Entonces: según los documentos, esto no es posible. Entonces, ¿qué está haciendo moc aquí?

Las máquinas tragamonedas pueden tener valores de retorno , entonces ¿podemos conectar una ranura con un valor de retorno a una señal con un valor de retorno ahora? Que eso sea posible, después de todo? Si es así, ¿es útil?

EDITAR: No estoy pidiendo soluciones, así que no proporciones ninguna.

EDITAR: Obviamente no es útil en el modo Qt::QueuedConnection (tampoco lo es la API QPrintPreviewWidget , y aún existe y es útil). Pero ¿qué pasa con Qt::DirectConnection y Qt::BlockingQueuedConnection (o Qt::AutoConnection , cuando se resuelve en Qt::DirectConnection ).

Answer 1

DE ACUERDO. Entonces, investigué un poco más. Parece que esto es posible. Pude emitir una señal y recibir valor de la ranura a la que estaba conectada la señal. Pero el problema fue que solo devolvió el último valor devuelto de las múltiples ranuras conectadas:

Aquí hay una definición de clase simple ( main.cpp ):

#include <QObject>
#include <QDebug>

class TestClass : public QObject
{
    Q_OBJECT
public:
    TestClass();

Q_SIGNALS:
    QString testSignal();

public Q_SLOTS:
    QString testSlot1() {
        return QLatin1String("testSlot1");
    }
    QString testSlot2() {
        return QLatin1String("testSlot2");
    }
};

TestClass::TestClass() {
    connect(this, SIGNAL(testSignal()), this, SLOT(testSlot1()));
    connect(this, SIGNAL(testSignal()), this, SLOT(testSlot2()));

    QString a = emit testSignal();
    qDebug() << a;
}

int main() {
    TestClass a;
}

#include "main.moc"

Cuando se ejecuta principalmente, construye una de las clases de prueba. El constructor conecta dos ranuras a la señal testSignal y luego emite la señal. Captura el valor de retorno de la (s) ranura (s) invocada (s).

Lamentablemente, solo obtiene el último valor de retorno. Si evalúa el código anterior, obtendrá: "testSlot2", el último valor de retorno de las ranuras conectadas de la señal.

Este es el por qué. Las señales de Qt son una interfaz azucarada de sintaxis para el patrón de señalización. Las máquinas tragamonedas son los destinatarios de una señal. En una relación de ranura de señal conectada directamente, podría pensar que es similar a (pseudo-código):

foreach slot in connectedSlotsForSignal(signal):
    value = invoke slot with parameters from signal
return value

Obviamente, el moc hace un poco más para ayudar en este proceso (verificación de tipo rudimentario, etc.), pero esto ayuda a pintar la imagen.

Answer 2

La función qt_metacall de Qt devuelve un código de estado entero. Debido a esto, creo que esto hace que un valor de retorno real sea imposible (a menos que te vuelvas loco con el sistema meta objeto y los archivos moc después de la precompilación).

Sin embargo, tiene parámetros de función normales a su disposición. Debería ser posible modificar su código de tal manera que use parámetros de "salida" que actúen como su "devolución".

void ClassObj::method(return_type * return_)
{
    ...

    if(return_) *return_ = ...;
}

// somewhere else in the code...

return_type ret;
emit this->method(&ret);

Answer 3

No, no pueden.

Boost::signals son bastante diferentes de las de Qt. Los primeros proporcionan un mecanismo de devolución de llamada avanzada, mientras que los últimos implementan el modismo de señalización. En el contexto del multihilo, las señales de Qt (rosca cruzada) dependen de las colas de mensajes, por lo que se llaman asíncronamente en algún punto (desconocido para el hilo del emisor) en el tiempo.

Answer 4

Puede intentar solucionar esto con lo siguiente:

1. Todas las ranuras conectadas deben guardar sus resultados en algún lugar (contenedor) accesible desde el objeto de señalización
2. La última ranura conectada debe de alguna manera (seleccionar máximo o último valor) procesar los valores recopilados y exponer el único
3. El objeto emisor puede intentar acceder a este resultado

Solo como una idea

Answer 5

Puede obtener un valor de retorno de la Qt signal con el siguiente código:

Mi ejemplo muestra cómo usar una Qt signal para leer el texto de un QLineEdit . Solo extiendo lo que @jordan ha propuesto:

Debería ser posible modificar su código de tal manera que use parámetros de "salida" que actúen como su "devolución".

#include <QtCore>
#include <QtGui>

class SignalsRet : public QObject
{
    Q_OBJECT

public:
    SignalsRet()
    {
        connect(this, SIGNAL(Get(QString*)), SLOT(GetCurrentThread(QString*)), Qt::DirectConnection);
        connect(this, SIGNAL(GetFromAnotherThread(QString*)), SLOT(ReadObject(QString*)), Qt::BlockingQueuedConnection);
        edit.setText("This is a test");
    }

public slots:
    QString call()
    {
        QString text;
        emit Get(&text);
        return text;
    }

signals:
    void Get(QString *value);
    void GetFromAnotherThread(QString *value);

private slots:
    void GetCurrentThread(QString *value)
    {
        QThread *thread = QThread::currentThread();
        QThread *mainthread = this->thread();
        if(thread == mainthread) //Signal called from the same thread that SignalsRet class was living
            ReadObject(value);
        else //Signal called from another thread
            emit GetFromAnotherThread(value);
    }

    void ReadObject(QString *value)
    {
        QString text = edit.text();
        *value = text;
    }

private:
    QLineEdit edit;

};

Para usar esto, solo solicite call(); .