come aggiungere un ritardo di 1 secondo usando Qtimer

Question

momento ho un metodo che è la seguente

void SomeMethod(int a) 
{ 

    //Delay for one sec. 
    timer->start(1000); 

    //After one sec 
    SomeOtherFunction(a); 
} 

Questo metodo è in realtà una fessura che è collegato ad un segnale. Vorrei aggiungere un ritardo di un secondo usando Qtimer. Tuttavia non sono sicuro su come farlo. Poiché il timer attiva un segnale quando è finito e il segnale dovrebbe essere collegato a un altro metodo che non contiene alcun parametro. Qualche suggerimento su come potrei realizzare questo compito?

Aggiornamento: Il segnale verrà chiamato più volte in un secondo e il ritardo sarà per un secondo. Il mio problema qui è passare un parametro allo slot collegato al segnale di timeout() di un timer. Il mio ultimo approccio sarebbe quello di memorizzare il valore in una variabile memeber di una classe e quindi utilizzare un mutex per proteggerlo dalla modifica mentre la variabile viene utilizzata. In ogni caso, sto cercando metodi più semplici qui.

Answer 1

Sono un po 'confuso dal modo in cui si formula la domanda, ma se si sta chiedendo come ottenere il segnale di timeout() del timer per chiamare una funzione con un parametro, è possibile creare uno slot separato per ricevere il timeout e quindi chiamare la funzione desiderata. Qualcosa di simile a questo: -

class MyClass : public QObject 
{ 
    Q_OBJECT 

public: 
    MyClass(QObject* parent); 

public slots: 

    void TimerHandlerFunction(); 
    void SomeMethod(int a); 

private: 
    int m_a; 
    QTimer m_timer; 

}; 

Implementazione: -

MyClass::MyClass(QObject* parent) 
    :QObject(parent) 
{ 
    // connect the timer's timeout to our TimerHandlerFunction 
    connect(&m_timer, SIGNAL(timout()), this, SLOT(TimerHandlerFunction())); 
} 

void MyClass::SomeMethod(int a) 
{ 
    m_a = a; // store the value to pass later 

    m_timer.setSingleShot(true); // if you only want it to fire once 
    m_timer.start(1000); 
} 

void MyClass::TimerHandlerFunction() 
{ 
    SomeOtherFunction(m_a); 
} 

Nota che la classe QObject in realtà ha un timer che è possibile utilizzare chiamando startTimer(), quindi in realtà non ha bisogno di usare un oggetto QTimer separato qui. È incluso qui per cercare di mantenere il codice di esempio vicino alla domanda.

Answer 2

Se si chiama SomeMethod più volte al secondo e il ritardo è sempre costante, si potrebbe mettere il parametro a ad un QQueue e creare un unico timer colpo per chiamare SomeOtherFunction, che ottiene il parametro dal QQueue.

void SomeClass::SomeMethod(int a) 
{ 
    queue.enqueue(a); 
    QTimer::singleShot(1000, this, SLOT(SomeOtherFunction())); 
} 

void SomeClass::SomeOtherFunction() 
{ 
    int a = queue.dequeue(); 
    // do something with a 
} 

Answer 3

In realtà, c'è un modo molto più soluzione elegante alla tua domanda che non necessita di variabili membro o code. Con Qt 5.4 e C++ 11 puoi run a Lambda expression right from the QTimer::singleShot(..) method! Se si utilizza Qt 5.0 - 5.3, è possibile utilizzare il metodo di connessione su connect the QTimer's timeout signal to a Lambda expression che chiamerà il metodo che deve essere ritardato con il parametro appropriato.

Modifica: Con la versione Qt 5.4 è solo una riga di codice!

Qt 5.4 (e versioni successive)

void MyClass::SomeMethod(int a) { 
    QTimer::singleShot(1000, []() { SomeOtherFunction(a); }); 
} 

Qt 5,0 - 5,3

void MyClass::SomeMethod(int a) { 
    QTimer *timer = new QTimer(this); 
    timer->setSingleShot(true); 

    connect(timer, &QTimer::timeout, [=]() { 
    SomeOtherFunction(a); 
    timer->deleteLater(); 
    }); 

    timer->start(1000); 
} 

Answer 4

che non funziona perché QTimer::start non stia bloccando.

È necessario avviare il timer con QTimer::singleShot e collegarlo a uno slot che verrà eseguito dopo il timeout di QTimer.