QTimer :: singleShot e QMetaMethod :: invoke

Question

In alcuni esempi di Qt, vedo che usano QTimer::singleShot(0, this , SLOT(funcA())), perché non chiamare direttamente lo slot funcA? anche la stessa domanda per l'utilizzo di QMetaMethod::invoke per chiamare la funzione con i parametri.

Answer 1

Le seguenti linee sono tutti funzionalmente equivalenti:

QTimer::singleShot(0, object, &Class::funcA); // Qt 5 
QTimer::singleShot(0, object, SLOT(funcA())); // Qt 4 
QMetaObject::invokeMethod(object, "funcA", Qt::QueuedConnection); 

Come è ora evidente, l'intento è quello di eseguire la chiamata entro il ciclo degli eventi. La chiamata in coda risulta nella pubblicazione di un numero QMetaCallEvent in object. Questo evento è gestito da QObject::event e genera la chiamata del metodo desiderato. Così, i seguenti sono esattamente equivalente, anche se quest'ultimo è un dettaglio di implementazione privata - avermi permesso di saltare the details of instantiating the event:

QMetaObject::invokeMethod(object, "funcA", Qt::QueuedConnection); 
QCoreApplication::postEvent(object, new QMetaCallEvent{...}); 

Questo è particolarmente utile in varie situazioni. Per esempio:

• di eseguire del codice eventi dopo tutto finora pubblicati sono stati gestiti.

• Da eseguire solo dopo l'avvio del ciclo degli eventi.

• Per chiamare un metodo invokable che non è accessibile a causa dei modificatori di accesso C++. I metodi invokable sono: segnali, slot e metodi dichiarati Q_INVOKABLE.

• La chiamata diretta non è sicura (leggi: un errore!) Quando uno QObject si trova in un altro thread, a meno che non si chiami esplicitamente un metodo documentato come thread-safe.

La chiamata in coda è una necessità se si vuole garantire che un ciclo di eventi si chiude immediatamente: un quit() chiamata diretta è un no-op, se il ciclo non è ancora in esecuzione.

int main(int argc, char ** argv) { 
    QCoreApplication app{argc, argv}; 
    app.quit(); // this is a no-op since the event loop isn't running yet 
    return app.exec(); // will not quit as desired 
} 

int main(int argc, char ** argv) { 
    QCoreApplication app{argc, argv}; 
    QMetaObject::invokeMethod(&app, "quit", Qt::QueuedConnection); 
    return app.exec(); // will return immediately 
} 

Idealmente, utilizza postToThread da this answer, offre il modo più basso costo di chiamare metodi in altri thread:

int main(int argc, char ** argv) { 
    QCoreApplication app{argc, argv}; 
    postToThread([]{ qApp->quit(); }); 
} 

Un modo alternativo per farlo sta usando una QObject come sorgente del segnale:

int main(int argc, char ** argv) { 
    QCoreApplication app{argc, argv}; 
    { 
    QObject src; 
    src.connect(&src, &QObject::destroyed, &app, &QCoreApplication::quit, 
       Qt::QueuedConnection); 
    } 
    return app.exec(); // will return immediately 
} 

un altro modo sarebbe quello di utilizzare un evento personalizzato e agire in suo distruttore:

int main(int argc, char ** argv) { 
    QCoreApplication app{argc, argv}; 
    struct QuitEvent : QEvent { 
    QuitEvent() : QEvent(QEvent::None) {} 
    ~QuitEvent() { qApp->quit(); } 
    }; 
    QCoreApplication::postEvent(&app, new QuitEvent); 
    return app.exec(); // will return immediately 
} 

Answer 2

Ogni sistema ha un ciclo di eventi in cui vengono elaborati gli eventi. Dire come

application::processEvents() 
{ 
// process event list.. 
} 

ora il luogo in cui si scrive QTimer::singleShot(0, this, SLOT(doSomething())); potrebbe essere all'interno di un evento di trasformazione. Al termine di questo ciclo, processEvents verrà richiamato e verrà eseguito doSomething().

Quindi questo è come chiamare doSomething nel prossimo ciclo degli eventi, piuttosto che chiamarlo immediatamente. Spero che tu abbia avuto l'idea.

Answer 3

Questi metodi possono anche essere utilizzati per invocare membri protetti e privati ​​di una classe (se definiti come slot) da un ambito che altrimenti richiederebbe l'accesso pubblico.