Sto cercando di aggiungere un ritardo temporizzato in un programma C ++ e mi chiedevo se qualcuno ha qualche suggerimento su cosa posso provare o informazioni che posso guardare?
Vorrei avere maggiori dettagli su come sto implementando questo ritardo temporizzato, ma finché non avrò maggiori informazioni su come aggiungere un ritardo temporizzato non sono sicuro di come dovrei tentare di implementarlo.
Risposte:
Win32: Sleep(milliseconds)è quello che fai
unix: usleep(microseconds)è quello che vuoi.
sleep () richiede solo un numero di secondi che spesso è troppo lungo.
Una risposta aggiornata per C ++ 11:
Usa le funzioni sleep_fore 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 c'è più la necessità di aggiungere continuamente nuove funzioni per una migliore risoluzione: sleep, usleep, nanosleep, ecc sleep_fore sleep_untilsono funzioni template che possono accettare i valori di qualsiasi risoluzione tramite chronoi tipi; ore, secondi, femtosecondi, ecc.
In C ++ 14 puoi semplificare ulteriormente il codice con i suffissi letterali per nanosecondse seconds:
#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 una sospensione dipende dall'implementazione: puoi chiedere di dormire per 10 nanosecondi, ma un'implementazione potrebbe invece finire per dormire per un millisecondo, se è il più breve possibile.
#include <unistd.h>
usleep(3000000);
Anche questo dormirà per tre secondi. Puoi perfezionare un po 'di più i numeri.
Vuoi qualcosa di semplice come
sleep(3);
Si noti che questo non garantisce che la quantità di tempo in cui il thread dorme sarà vicino al periodo di sospensione, ma garantisce solo che la quantità di tempo prima che il thread continui l'esecuzione sarà almeno la quantità desiderata. Il ritardo effettivo varierà a seconda delle circostanze (in particolare il carico sulla macchina in questione) e potrebbe essere di ordini di grandezza superiore al tempo di sospensione desiderato.
Inoltre, non elenchi il motivo per cui devi dormire, ma in genere dovresti evitare di utilizzare i ritardi come metodo di sincronizzazione.
Puoi provare questo snippet 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));
}
Puoi anche usare select (2) se vuoi una precisione al microsecondo (funziona su piattaforme che non hanno usleep (3))
Il codice seguente attenderà 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);
}
"
Sì, il sonno è probabilmente la funzione di scelta qui. Si noti che il tempo passato nella funzione è la quantità minima di tempo in cui il thread chiamante sarà inattivo. Quindi, ad esempio, se chiami sleep con 5 secondi, hai la garanzia che il tuo 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 caratteristica della funzione sleep è di passare a 0. Ciò forzerà un cambio di contesto dal thread.
Alcune informazioni aggiuntive:
http://www.opengroup.org/onlinepubs/000095399/functions/sleep.html
Ho scoperto che "_sleep(milliseconds);"(senza virgolette) funziona bene per Win32 se includi la chronolibreria
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.
per ritardare l'output in cpp per un tempo fisso, è possibile utilizzare la funzione Sleep () includendo la sintassi del file di intestazione windows.h per la funzione Sleep () è Sleep (time_in_ms) come
cout<<"Apple\n";
Sleep(3000);
cout<<"Mango";
PRODUZIONE. il codice sopra stamperà Apple e attenderà 3 secondi prima di stampare Mango.
La risposta principale qui sembra essere una risposta dipendente dal sistema operativo; per una soluzione più portabile è possibile scrivere una funzione di sospensione rapida utilizzando il file di intestazione ctime (sebbene questa potrebbe essere un'implementazione scadente da parte mia).
#include <iostream>
#include <ctime>
using namespace std;
void sleep(float seconds){
clock_t startClock = clock();
float secondsAhead = seconds * CLOCKS_PER_SEC;
// do nothing until the elapsed time has passed.
while(clock() < startClock+secondsAhead);
return;
}
int main(){
cout << "Next string coming up in one second!" << endl;
sleep(1.0);
cout << "Hey, what did I miss?" << endl;
return 0;
}
Sintassi:
void sleep (secondi senza segno);
sleep () sospende l'esecuzione per un intervallo (secondi). Con una chiamata a sleep, 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 alla precisione dell'orologio del sistema operativo, a seconda di quale dei due è meno accurato.
Molti altri hanno fornito buone informazioni per dormire. Concordo con Wedge sul fatto che dormire raramente è la soluzione più appropriata.
Se stai dormendo mentre aspetti qualcosa, allora è meglio aspettare davvero quella cosa / evento. Guarda le variabili di condizione per questo.
Non so su quale sistema operativo stai cercando di farlo, ma per il threading e la sincronizzazione potresti guardare alle librerie Boost Threading ( Boost Condition Varriable ).
Passando ora all'altro estremo se stai cercando di aspettare per periodi eccezionalmente brevi, ci sono un paio di opzioni di stile di hacking. Se stai lavorando su una sorta di piattaforma incorporata in cui uno "sleep" non è implementato, puoi provare un semplice ciclo (for / while ecc.) Con un corpo vuoto (fai attenzione che il compilatore non lo ottimizzi). Ovviamente in questo caso il tempo di attesa dipende dall'hardware specifico. Per "attese" davvero brevi puoi provare un assembly "nop". Dubito fortemente che questo sia ciò che stai cercando, ma senza sapere perché devi aspettare è difficile essere più specifici.
Su Windows puoi includere la libreria di Windows e usare "Sleep (0);" per mettere in pausa il programma. Prende un valore che rappresenta i millisecondi.