Pregunta acerca de la aplicación.exec() y la función de bucle en Qt

Question 1

No app.exec() un bucle infinito que devuelve main() ?

Quiero un bucle de cliente de servidor de comunicación de abajo, pero se ejecuta sólo queridos y, a continuación, la función principal termina con app.exec()

Soy nuevo tanto en Qt y C++, ¿cómo puedo gestionar este bucle?

int main(int argc, char *argv[])
{
    cout << "Waiting for the next request " << endl;
    QApplication app(argc, argv);

    //  Prepare our context and socket
    zmq::context_t context(1);
    zmq::socket_t socket(context, ZMQ_REP);
    socket.bind("tcp://*:2424");
    zmq::message_t request;


    QQmlApplicationEngine engine;

    VideoStreamer videoStreamer;
    imageProvider *liveOriginalImageProvider(new imageProvider);
    imageProvider *liveMaskedImageProvider(new imageProvider);

    //********SERVER CLIENT COMMUNICATION BEGINS******//

    // Wait for next request from client
    cout << "Waiting for the next request ." << endl;
    socket.recv(&request);
    cout << "Waiting for the next request.. " << endl;
    string replyMessage = string(static_cast<char *>(request.data()), request.size());

    // Print out received message
    cout << "Received from client (Python): " + replyMessage << endl;

    //  See the gradual sending/replying from client
    sleep(1);

    //  Send reply back to client
    string msgToClient("W");
    zmq::message_t reply(msgToClient.size());
    memcpy((void *) reply.data(), (msgToClient.c_str()), msgToClient.size());
    socket.send(reply);

    //*********SERVER CLIENT COMMUNICATION ENDS**********//

    engine.rootContext()->setContextProperty("VideoStreamer",&videoStreamer);
    engine.rootContext()->setContextProperty("liveOriginalImageProvider",liveOriginalImageProvider);
    engine.rootContext()->setContextProperty("liveMaskedImageProvider",liveMaskedImageProvider);

    engine.addImageProvider("liveOriginal",liveOriginalImageProvider);
    engine.addImageProvider("liveMasked",liveMaskedImageProvider);


    const QUrl url(QStringLiteral("qrc:/main.qml"));
    engine.load(url);

    QObject::connect(&videoStreamer,&VideoStreamer::originalImage,liveOriginalImageProvider,&imageProvider::updateImage);
    QObject::connect(&videoStreamer,&VideoStreamer::maskedImage,liveMaskedImageProvider,&imageProvider::updateImage);

    return app.exec();
}

---------ACTUALIZACIÓN---------

He creado este hilo en el hilo.h

class MyThread : public QThread{
public slots:
    void run();
};

en thread.cpp yo he declarado el método:

void MyThread :: run() {
    //  Prepare our context and socket
    zmq::context_t context(1);
    zmq::socket_t socket(context, ZMQ_REP);
    socket.bind("tcp://*:2424");
    zmq::message_t request;

    //********SERVER CLIENT COMMUNICATION BEGINS******//

    // Wait for next request from client
    cout << "Waiting for the next request ." << endl;
    socket.recv(&request);
    cout << "Waiting for the next request.. " << endl;
    string replyMessage = string(static_cast<char *>(request.data()), request.size());

    // Print out received message
    cout << "Received from client (Python): " + replyMessage << endl;

    //  See the gradual sending/replying from client
    sleep(1);

    //  Send reply back to client
    string msgToClient("W");
    zmq::message_t reply(msgToClient.size());
    memcpy((void *) reply.data(), (msgToClient.c_str()), msgToClient.size());
    socket.send(reply);

    exec();
    //*********SERVER CLIENT COMMUNICATION ENDS**********//
}

en main.cpp me llama:

QThread *thread = new QThread();

MyThread *myThread = new MyThread();
myThread->moveToThread(thread);
myThread->connect(thread, SIGNAL(started()), myThread, SLOT(run()));

thread->start();

Puedo conseguir Error: Class declaration lacks Q_OBJECT macro. No QThread heredar la QObject? ¿Cómo puedo llamar el bucle correctamente?

Question 2

Uno de los principales proyectos en los que trabajo en el que ahora utiliza Qt y ZMQ - Su ZMQ sockets necesitan vivir dentro de un QObject que se ejecuta en la aplicación del bucle de eventos, no en el interior de la main() función de su aplicación

He aquí una muy abreviada de la vista de cómo uno de nuestros ZMQ sockets comunica sobre el Qt bucle de eventos - la aplicación tiene una ZMQ_SUB socket conectado a un ZMQ_PUB enchufe en el otro extremo de la publicación de eventos a partir de una interfaz de hardware

int main(int argc, char* argv[])
{
   QApplication app(argc, argv);
   ...
   ConnectionManager connMgr; // Create connection class - is a QObject subclass
   connMgr.connect(target);

   MainWindow mainWin; // Create GUI classes

   return app.exec();
}

void ConnectionManager::connect(std::string target)
{
    context = zmq_ctx_new();

    zsocket = zmq_socket(context, ZMQ_SUB);
    zmq_connect(zsocket, (connection + ":" + REQUEST_PORT).c_str());
    ...

    QTimer pollTimer;
    pollTimer.callOnTimeout(this, &ConnectionManager::onPollTimer);
    pollTimer.start(100);
}

void ConnectionManager::onPollTimer()
{
    uint16_t length = 0;

    const size_t buffer_length = 1024;
    uint8_t* buffer = new uint8_t[buffer_length];

    do
    {
        int64_t more = 0;
        size_t more_size = sizeof more;
        auto len = zmq_recv(zsocket, buffer + length, buffer_length - length, ZMQ_NOBLOCK);
        if (len == -1)
        {
            return;
        }
        else if (len > 0)
        {
            length += len;
            auto rc = zmq_getsockopt(socket, ZMQ_RCVMORE, &more, &more_size);
        }
    } while (more);

    std::cout << "Received" << length << "bytes";
    HandleMessage(buffer, length); // Process the incoming message
}

En esencia, app.exec() Crea un bucle infinito, pero que existe dentro del bucle QApplication objeto, no uno que sólo se ejecuta repetidamente el main() función de donde fue llamado, y para hacer uso de ese bucle su aplicación debe crear instancias adicionales de QObject subclases y el uso de la señal/espacio/QEvent/QTimer mecanismos para realizar acciones en respuesta a las acciones del usuario/eventos de entrada/intervalos de tiempo

rdowell · Answer 1 · 2021-11-23T18:47:50

Uno de los principales proyectos en los que trabajo en el que ahora utiliza Qt y ZMQ - Su ZMQ sockets necesitan vivir dentro de un QObject que se ejecuta en la aplicación del bucle de eventos, no en el interior de la main() función de su aplicación

He aquí una muy abreviada de la vista de cómo uno de nuestros ZMQ sockets comunica sobre el Qt bucle de eventos - la aplicación tiene una ZMQ_SUB socket conectado a un ZMQ_PUB enchufe en el otro extremo de la publicación de eventos a partir de una interfaz de hardware

int main(int argc, char* argv[])
{
   QApplication app(argc, argv);
   ...
   ConnectionManager connMgr; // Create connection class - is a QObject subclass
   connMgr.connect(target);

   MainWindow mainWin; // Create GUI classes

   return app.exec();
}

void ConnectionManager::connect(std::string target)
{
    context = zmq_ctx_new();

    zsocket = zmq_socket(context, ZMQ_SUB);
    zmq_connect(zsocket, (connection + ":" + REQUEST_PORT).c_str());
    ...

    QTimer pollTimer;
    pollTimer.callOnTimeout(this, &ConnectionManager::onPollTimer);
    pollTimer.start(100);
}

void ConnectionManager::onPollTimer()
{
    uint16_t length = 0;

    const size_t buffer_length = 1024;
    uint8_t* buffer = new uint8_t[buffer_length];

    do
    {
        int64_t more = 0;
        size_t more_size = sizeof more;
        auto len = zmq_recv(zsocket, buffer + length, buffer_length - length, ZMQ_NOBLOCK);
        if (len == -1)
        {
            return;
        }
        else if (len > 0)
        {
            length += len;
            auto rc = zmq_getsockopt(socket, ZMQ_RCVMORE, &more, &more_size);
        }
    } while (more);

    std::cout << "Received" << length << "bytes";
    HandleMessage(buffer, length); // Process the incoming message
}

En esencia, app.exec() Crea un bucle infinito, pero que existe dentro del bucle QApplication objeto, no uno que sólo se ejecuta repetidamente el main() función de donde fue llamado, y para hacer uso de ese bucle su aplicación debe crear instancias adicionales de QObject subclases y el uso de la señal/espacio/QEvent/QTimer mecanismos para realizar acciones en respuesta a las acciones del usuario/eventos de entrada/intervalos de tiempo

Gracias por la explicación, pero esto es muy difícil para mí poner en práctica. Es posible pasar a través de esta situación utilizando los códigos que he escrito arriba?
En su pregunta se declaró "soy nuevo tanto en Qt y C++" - ¿eres nuevo en la programación en general, o ha escrito en otros idiomas, y usted está ahora tratando de hacer algo en C++/Qt por primera vez? Lo pregunto porque lo que estamos tratando aquí no es algo que yo recomendaría tratando de implementar como un programador principiante hasta que he conseguido mucho más familiarizados con el lenguaje en general y, a continuación, familiarizado con la forma de la aplicación Qt bucle de eventos y de la señal/de la ranura de los mecanismos de trabajo, ya que estos son mecanismos fundamentales para la escritura de aplicaciones Qt en general

Pregunta acerca de la aplicación.exec() y la función de bucle en Qt

Pregunta

Mejor respuesta

En otros idiomas

Esta página está en otros idiomas

Popular en esta categoría

Las preguntas más habituales en esta categoría