Domanda su app.exec() e loop in Qt

Question 1

Non è app.exec() un ciclo infinito che restituisce main() ?

Voglio loop il server di comunicazione con i clienti al di sotto, ma eseguito solo quelli e quindi la funzione principale termina con app.exec()

Sono nuovo sia di Qt e C++, come posso gestire questo loop?

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();
}

---------AGGIORNAMENTO---------

Ho creato questo thread in thread.h

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

in thread.cpp ho dichiarato il metodo:

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**********//
}

in main.cpp l'ho chiamata:

QThread *thread = new QThread();

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

thread->start();

Ho Error: Class declaration lacks Q_OBJECT macro. Non QThread ereditare il QObject? Come posso chiamare il loop correttamente?

Question 2

Uno dei principali progetti di lavoro, attualmente in usa Qt e ZMQ - Il ZMQ prese bisogno di vivere all'interno di un QObject che viene eseguito il ciclo di eventi, non all'interno della main() funzione dell'applicazione

Ecco un molto in forma abbreviata vista come uno dei nostri ZMQ prese comunica su Qt ciclo di eventi - l'app ha un ZMQ_SUB presa collegata a un ZMQ_PUB presa l'altra estremità la pubblicazione di eventi da un interfaccia 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
}

In sostanza, app.exec() Crea un ciclo infinito, ma che esiste all'interno del loop QApplication oggetto, non uno che esegue ripetutamente l' main() funzione, dove è stato chiamato da, e fare uso di tale ciclo di applicazione dovrebbe creare ulteriori istanze di QObject sottoclassi e utilizzare il signal/slot/QEvent/QTimer meccanismi di eseguire azioni in risposta alle azioni dell'utente/gli eventi di input/intervalli di tempo

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

Uno dei principali progetti di lavoro, attualmente in usa Qt e ZMQ - Il ZMQ prese bisogno di vivere all'interno di un QObject che viene eseguito il ciclo di eventi, non all'interno della main() funzione dell'applicazione

Ecco un molto in forma abbreviata vista come uno dei nostri ZMQ prese comunica su Qt ciclo di eventi - l'app ha un ZMQ_SUB presa collegata a un ZMQ_PUB presa l'altra estremità la pubblicazione di eventi da un interfaccia 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
}

In sostanza, app.exec() Crea un ciclo infinito, ma che esiste all'interno del loop QApplication oggetto, non uno che esegue ripetutamente l' main() funzione, dove è stato chiamato da, e fare uso di tale ciclo di applicazione dovrebbe creare ulteriori istanze di QObject sottoclassi e utilizzare il signal/slot/QEvent/QTimer meccanismi di eseguire azioni in risposta alle azioni dell'utente/gli eventi di input/intervalli di tempo

Grazie per la spiegazione, ma questo è veramente difficile per me da implementare. È possibile passare attraverso questa situazione utilizzando i codici che ho scritto sopra?
Nella tua domanda hai detto "io sono nuovo sia del Qt e C++" - sono nuovo della programmazione in generale o l'avete scritto in altre lingue e si sta solo ora cercando qualcosa in C++/Qt per la prima volta? Lo chiedo perchè quello che stai cercando qui non è qualcosa che vorrei raccomandare cercando di implementare un programmatore principiante fino a quando hai ottenuto molto più familiarità con la lingua in generale e familiarità con l'applicazione Qt ciclo di eventi di segnale e/slot meccanismi di lavoro, in quanto questi sono meccanismi fondamentali per la scrittura di applicazioni Qt in generale

Domanda su app.exec() e loop in Qt

Domanda

Migliore risposta

In altre lingue

Questa pagina è in altre lingue

Popolare in questa categoria

Domande popolari in questa categoria