¿Cómo agregar un retraso temporizado a un programa de C ++?

Question

Estoy tratando de agregar un retraso programado en un programa de C ++, y me preguntaba si alguien tiene alguna sugerencia sobre qué puedo probar o qué información puedo ver.

Desearía tener más detalles sobre cómo estoy implementando este retraso temporizado, pero hasta que tenga más información sobre cómo agregar un retraso programado, no estoy seguro de cómo debería intentar implementar esto.

Answer 1

Win32: Dormir (milisegundos) es lo que tú

unix: usleep (microseconds) es lo que querer.

sleep () solo tarda unos segundos, lo que suele ser demasiado largo.

Answer 2

Una respuesta actualizada para C ++ 11:

Utilice 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. < el código> sleep_for y sleep_until son funciones de plantilla que pueden aceptar valores de cualquier resolución a través de los tipos chrono ; horas, segundos, femtosegundos, etc.

En C ++ 14 puede simplificar aún más el código con los sufijos literales para nanosegundos y segundos :

#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 dormir durante 10 nanosegundos, pero una implementación podría terminar durmiendo por un milisegundo, si eso es lo más corto que puede hacer.

Answer 3

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

Esto también dormirá durante tres segundos. Sin embargo, puedes refinar los números un poco más.

Answer 4

¿Quieres algo tan simple como

sleep(3);

Answer 5

Tenga en cuenta que esto no garantiza que la cantidad de tiempo que duerme el subproceso estará cerca del período de suspensión, solo garantiza que la cantidad de tiempo antes de que continúe la ejecución de la hebra 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 de órdenes de magnitud más altas que el tiempo de reposo deseado.

Además, no indica por qué necesita dormir, pero generalmente debe evitar el uso de demoras como método de sincronización.

Answer 6

También puede usar select (2) si desea una precisión de microsegundos (esto funciona en una plataforma que no duerme (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);
}

`

Answer 7

Encontré que " _sleep (milisegundos); " (sin las comillas) funciona bien para Win32 si incluye la biblioteca chrono

E.g:

#include <chrono>

using namespace std;

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

Asegúrate de incluir el guión bajo antes de dormir.

Answer 8

Sí, el sueño es probablemente la función de elección aquí. Tenga en cuenta que el tiempo transcurrido en la función es la cantidad más pequeña de tiempo que el subproceso de llamada estará inactivo. Así, por ejemplo, si llama a dormir con 5 segundos, tiene la garantía de que su hilo estará durmiendo durante al menos 5 segundos. Podría ser 6, u 8 o 50, dependiendo de lo que esté haciendo el sistema operativo. (Durante la ejecución óptima del sistema operativo, esto estará muy cerca de 5.)
Otra función útil de la función de suspensión es pasar a 0. Esto forzará un cambio de contexto desde su hilo.

Alguna información adicional:
http://www.opengroup.org/onlinepubs/000095399/functions/sleep. html

Answer 9

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));
}

Answer 10

para retrasar la salida en cpp durante un tiempo fijo, puede usar la función Suspender () incluyendo el archivo de encabezado windows.h la sintaxis para la función Sleep () es Sleep (time_in_ms) como

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

SALIDA. el código anterior imprimirá a Apple y esperará 3 segundos antes de imprimir Mango.

Answer 11

Sintaxis:

sueño nulo (segundos sin firmar);

sleep () suspende la ejecución por un intervalo (segundos). Con una llamada a la 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 exacto solo hasta la centésima de segundo más cercana o la precisión del reloj del sistema operativo, lo que sea menos preciso.

Answer 12

Muchos otros han proporcionado buena información para dormir. Estoy de acuerdo con Wedge en que un sueño rara vez es la solución más adecuada.

Si estás durmiendo mientras esperas algo, entonces es mejor que esperes esa cosa / evento. Mira las variables de condición para esto.

No sé en qué sistema operativo está tratando de hacer esto, pero para los subprocesos y la sincronización puede consultar el Boost Threading bibliotecas ( Boost Condition Varriable ).

Mover ahora al otro extremo, si está tratando de esperar por períodos excepcionalmente cortos, hay un par de opciones de estilo de hackeo. Si está trabajando en algún tipo de plataforma integrada donde no se implementa un "reposo", puede probar un bucle simple (para / mientras que, 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, puede probar un ensamblaje " nop " ;. Dudo mucho que esto sea lo que buscas, pero sin saber por qué necesitas esperar, es difícil ser más específico.

Answer 13

En Windows puede incluir la biblioteca de Windows y usar " Reposo (0); " Para dormir el programa. Toma un valor que representa milisegundos.