Come si aggiunge un ritardo temporizzato a un programma C ++?

Question

Sto cercando di aggiungere un ritardo a tempo in un programma C ++ e mi chiedevo se qualcuno avesse qualche suggerimento su cosa posso provare o informazioni che posso guardare?

Vorrei avere maggiori dettagli su come sto implementando questo ritardo a tempo, ma fino a quando non avrò maggiori informazioni su come aggiungere un ritardo a tempo non sono sicuro di come dovrei tentare di implementarlo.

Answer 1

Win32: Il sonno (millisecondi) è ciò che fai

unix: usleep (microsecondi) è ciò che desiderare.

sleep () richiede solo un numero di secondi che spesso è troppo lungo.

Answer 2

Una risposta aggiornata per C ++ 11:

Utilizza le funzioni sleep_for e sleep_until :

#include <chrono>
#include <thread>

int main() {
    using namespace std::this_thread; // sleep_for, sleep_until
    using namespace std::chrono; // nanoseconds, system_clock, seconds

    sleep_for(nanoseconds(10));
    sleep_until(system_clock::now() + seconds(1));
}

Con queste funzioni non è più necessario aggiungere continuamente nuove funzioni per una migliore risoluzione: sleep , usleep , nanosleep , ecc. < code> sleep_for e sleep_until sono funzioni modello che possono accettare valori di qualsiasi risoluzione tramite i tipi chrono ; ore, secondi, femtosecondi, ecc.

In C ++ 14 puoi semplificare ulteriormente il codice con i suffissi letterali per nanosecondi e secondi :

#include <chrono>
#include <thread>

int main() {
    using namespace std::this_thread;     // sleep_for, sleep_until
    using namespace std::chrono_literals; // ns, us, ms, s, h, etc.
    using std::chrono::system_clock;

    sleep_for(10ns);
    sleep_until(system_clock::now() + 1s);
}

Nota che la durata effettiva di un sonno dipende dall'implementazione: puoi chiedere di dormire per 10 nanosecondi, ma un'implementazione potrebbe finire per dormire per un millisecondo, se è il più breve che può fare.

Answer 3

#include <unistd.h>
usleep(3000000);

Questo dormirà anche per tre secondi. Puoi affinare i numeri un po 'di più però.

Answer 4

Vuoi qualcosa di semplice come

sleep(3);

Answer 5

Nota che ciò non garantisce che il tempo di sospensione del thread sarà vicino al periodo di sospensione, garantisce solo che il tempo che deve trascorrere prima che il thread continui l'esecuzione sarà almeno la quantità desiderata. Il ritardo effettivo varierà a seconda delle circostanze (in particolare del carico sulla macchina in questione) e potrebbe essere ordini di grandezza superiori al tempo di sonno desiderato.

Inoltre, non elenchi il motivo per cui devi dormire, ma in genere dovresti evitare di utilizzare i ritardi come metodo di sincronizzazione.

Answer 6

Puoi anche usare select (2) se vuoi la precisione dei microsecondi (funziona su piattaforma che non ha usleep (3))

Il seguente codice attende 1,5 secondi:

#include <sys/select.h>
#include <sys/time.h>
#include <unistd.h>`

int main() {
    struct timeval t;
    t.tv_sec = 1;
    t.tv_usec = 500000;
    select(0, NULL, NULL, NULL, &t);
}

`

Answer 7

Ho scoperto che " _sleep (millisecondi); " (senza virgolette) funziona bene per Win32 se includi la libreria chrono

per esempio:

#include <chrono>

using namespace std;

main
{
    cout << "text" << endl;
    _sleep(10000); // pauses for 10 seconds
}

Assicurati di includere il trattino basso prima di andare a dormire.

Answer 8

Sì, il sonno è probabilmente la funzione di scelta qui. Si noti che il tempo trascorso nella funzione è il minor tempo in cui il thread chiamante sarà inattivo. Quindi, ad esempio, se chiami sleep con 5 secondi, sei sicuro che il thread dormirà per almeno 5 secondi. Potrebbe essere 6, o 8 o 50, a seconda di cosa sta facendo il sistema operativo. (Durante l'esecuzione ottimale del sistema operativo, questo sarà molto vicino a 5.)
Un'altra utile funzione della funzione sleep è passare in 0. Questo forzerà un cambio di contesto dal tuo thread.

Alcune informazioni aggiuntive:
http://www.opengroup.org/onlinepubs/000095399/functions/sleep. html

Answer 9

Puoi provare questo frammento di codice:

#include<chrono>
#include<thread>

int main(){
    std::this_thread::sleep_for(std::chrono::nanoseconds(10));
    std::this_thread::sleep_until(std::chrono::system_clock::now() + std::chrono::seconds(1));
}

Answer 10

per ritardare l'output in cpp per un tempo fisso, puoi usare la funzione Sleep () includendo il file header windows.h la sintassi della funzione Sleep () è Sleep (time_in_ms) come

cout<<"Apple\n";
Sleep(3000);
cout<<"Mango";

USCITA. il codice sopra stampa Apple e attende 3 secondi prima di stampare Mango.

Answer 11

La sintassi:

void sleep (secondi non firmati);

sleep () sospende l'esecuzione per un intervallo (secondi). Con una chiamata in sospensione, il programma corrente viene sospeso dall'esecuzione per il numero di secondi specificato dall'argomento secondi. L'intervallo è preciso solo al centesimo di secondo più vicino o all'accuratezza dell'orologio del sistema operativo, a seconda di quale sia meno preciso.

Answer 12

Molti altri hanno fornito buone informazioni per dormire. Concordo con Wedge sul fatto che dormire raramente sia la soluzione più appropriata.

Se stai dormendo mentre aspetti qualcosa, allora stai meglio aspettando quella cosa / evento. Guarda le variabili di condizione per questo.

Non so su quale SO stai cercando di farlo, ma per il threading e la sincronizzazione potresti guardare Boost Threading librerie ( Boost Condition Varriable ).

Passando ora all'altro estremo se stai cercando di aspettare periodi eccezionalmente brevi, ci sono un paio di opzioni di stile hack. Se stai lavorando su una sorta di piattaforma integrata in cui non è implementato un "sleep", puoi provare un semplice ciclo (per / mentre ecc.) Con un corpo vuoto (fai attenzione che il compilatore non lo ottimizzi via). Ovviamente in questo caso il tempo di attesa dipende dall'hardware specifico. Per "attese" davvero brevi puoi provare un assemblaggio "no". Dubito fortemente che questo sia ciò che stai cercando, ma senza sapere perché devi aspettare è difficile essere più specifici.

Answer 13

Su Windows puoi includere la libreria di Windows e utilizzare " Sleep (0); " per dormire il programma. Prende un valore che rappresenta i millisecondi.