segundo - ¿Cómo se agrega un retraso temporizado a un programa en C++?
pausar pantalla en c++ (13)
¿Quieres algo tan simple como
sleep(3);
Estoy tratando de agregar un retraso en el tiempo en un programa de C ++, y me preguntaba si alguien tiene alguna sugerencia sobre lo que puedo probar o la información que puedo ver.
Desearía tener más detalles sobre cómo estoy implementando este retraso programado, pero hasta que tenga más información sobre cómo agregar un retraso temporizado, no estoy seguro de cómo debería siquiera intentar implementarlo.
En Windows puede incluir la biblioteca de Windows y usar "Sleep (0);" dormir el programa Toma un valor que representa milisegundos.
Encontré ese "_sleep(milliseconds);" (sin las comillas) funciona bien para Win32 si incluye la biblioteca chrono
P.ej:
#include <chrono>
using namespace std;
main
{
cout << "text" << endl;
_sleep(10000); // pauses for 10 seconds
}
Asegúrese de incluir el guión bajo antes de dormir.
Muchos otros han proporcionado buena información para dormir. Estoy de acuerdo con Wedge en que dormir rara vez es la solución más adecuada.
Si duermes mientras esperas algo, entonces es mejor que realmente esperes esa cosa / evento. Mire las variables de condición para esto.
No sé en qué sistema operativo está intentando hacer esto, pero para enhebrar y sincronizar podría consultar las bibliotecas de Boost Threading ( Boost Condition Varriable ).
Moviéndote ahora al otro extremo si estás tratando de esperar periodos excepcionalmente cortos, entonces hay un par de opciones de estilo de piratería. Si está trabajando en algún tipo de plataforma incrustada donde no se implementa un ''sueño'', entonces puede probar un bucle simple (para / while, etc.) con un cuerpo vacío (tenga cuidado de que el compilador no lo optimice). Por supuesto, el tiempo de espera depende del hardware específico en este caso. Para ''esperas'' realmente cortas, puedes probar un ensamblado "nop". Dudo mucho que esto sea lo que buscas, pero sin saber por qué tienes que esperar, es difícil ser más específico.
Puedes probar este fragmento de código:
#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));
}
Sí, dormir es probablemente la función de elección aquí. Tenga en cuenta que el tiempo transcurrido en la función es la menor cantidad de tiempo que el hilo llamante estará inactivo. Entonces, por ejemplo, si llamas a dormir con 5 segundos, tienes garantizado que tu hilo durmirá durante al menos 5 segundos. Podría ser 6, o 8 o 50, según lo que esté haciendo el sistema operativo. (Durante la ejecución óptima del sistema operativo, esto será muy cercano a 5.)
Otra función útil de la función dormir es pasar 0. Esto forzará un cambio de contexto de su hilo.
Alguna información adicional:
http://www.opengroup.org/onlinepubs/000095399/functions/sleep.html
Sintaxis:
sueño vacío (segundos sin signo);
sleep () suspende la ejecución durante un intervalo (segundos). Con una llamada a suspensión, el programa actual se suspende de la ejecución durante el número de segundos especificado por el argumento segundos. El intervalo es preciso solo a la centésima de segundo más cercana o a la precisión del reloj del sistema operativo, el que sea menos preciso.
También puede usar select (2) si quiere precisión de microsegundos (esto funciona en una plataforma que no tiene usleep (3))
El siguiente código esperará 1.5 segundos:
#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);
}
`
Tenga en cuenta que esto no garantiza que la cantidad de tiempo que dure el hilo sea cercana al período de reposo, solo garantiza que la cantidad de tiempo antes de que el hilo continúe la ejecución será al menos la cantidad deseada. El retraso real variará según las circunstancias (especialmente la carga en la máquina en cuestión) y puede ser órdenes de magnitud mayor que el tiempo de sueño deseado.
Además, no enumera por qué necesita dormir, pero generalmente debe evitar el uso de retrasos como método de sincronización.
Una respuesta actualizada para C ++ 11:
Use las funciones sleep_for y 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 estas funciones, ya no es necesario agregar continuamente nuevas funciones para una mejor resolución: sleep , usleep , nanosleep , etc. sleep_for y sleep_until son funciones de plantilla que pueden aceptar valores de cualquier resolución a través de tipos de chrono ; horas, segundos, femtosegundos, etc.
En C ++ 14 puedes simplificar aún más el código con los sufijos literales para nanoseconds y 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);
}
Tenga en cuenta que la duración real de un sueño depende de la implementación: puede pedir que duerma durante 10 nanosegundos, pero una implementación puede terminar durmiendo durante un milisegundo, si es lo más corto que puede hacer.
para retrasar la salida en cpp durante un tiempo fijo, puede usar la función Sleep () incluyendo la sintaxis del archivo de encabezado windows.h para la función Sleep () es Sleep (time_in_ms) como
cout<<"Apple/n";
Sleep(3000);
cout<<"Mango";
SALIDA. El código anterior imprimirá Apple y esperará 3 segundos antes de imprimir Mango.
Win32: Sleep(milliseconds) es lo que tu que
unix: usleep(microseconds) es lo que quieres.
sleep () solo toma un número de segundos, que a menudo es demasiado largo.
#include <unistd.h>
usleep(3000000);
Esto también dormirá por tres segundos. Sin embargo, puedes refinar los números un poco más.