¿Cómo se agrega un retraso cronometrado a un programa de C ++?

Estoy tratando de agregar un retraso cronometrado en un programa de C ++ y me preguntaba si alguien tiene alguna sugerencia sobre lo que puedo probar o información que puedo ver.

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

Win32: Sleep(milliseconds)es lo que tu

unix: usleep(microseconds)es lo que quieres.

sleep () solo toma unos segundos, que a menudo es demasiado largo.

Una respuesta actualizada para C ++ 11:

Utilice las funciones sleep_fory 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 hay necesidad de añadir continuamente nuevas funciones para una mejor resolución: sleep, usleep, nanosleep, etc sleep_for, y sleep_untilson funciones de plantilla que pueden aceptar valores de cualquier resolución a través de chronotipos; horas, segundos, femtosegundos, etc.

En C ++ 14, puede simplificar aún más el código con los sufijos literales para nanosecondsy 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 una suspensión depende de la implementación: puede solicitar dormir durante 10 nanosegundos, pero una implementación podría terminar durmiendo durante un milisegundo, si eso es lo más corto que puede hacer.

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

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

¿Quieres algo tan simple como

sleep(3);

Tenga en cuenta que esto no garantiza que la cantidad de tiempo que el hilo duerme estará cerca del período de espera, solo garantiza que la cantidad de tiempo antes de que el hilo continúe ejecutándose será al menos la cantidad deseada. La demora 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 suspensión deseado.

Además, no enumera por qué necesita dormir, pero generalmente debe evitar usar retrasos como método de sincronización.

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

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

'

Sí, dormir es probablemente la función elegida aquí. Tenga en cuenta que el tiempo transcurrido en la función es la menor cantidad de tiempo que el hilo de llamada estará inactivo. Entonces, 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, 8 o 50, dependiendo de lo que esté haciendo el sistema operativo. (Durante la ejecución óptima del sistema operativo, estará muy cerca de 5.)
Otra característica útil de la función de suspensión es pasar 0. Esto forzará un cambio de contexto desde su hilo.

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

Descubrí que "_sleep(milliseconds);"(sin las comillas) funciona bien para Win32 si incluye la chronobiblioteca

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.

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.

La respuesta principal aquí parece ser una respuesta dependiente del sistema operativo; para una solución más portátil, puede escribir una función de suspensión rápida utilizando el archivo de encabezado ctime (aunque esto puede ser una mala implementación de mi parte).

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

Sintaxis:

sueño nulo (segundos sin firmar);

sleep () suspende la ejecución durante un intervalo (segundos). Con una llamada a dormir, se suspende la ejecución del programa actual durante el número de segundos especificado por el argumento segundos. El intervalo es exacto solo a la centésima de segundo más cercana o a la precisión del reloj del sistema operativo, lo que sea menos exacto.

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 estás durmiendo mientras esperas algo, entonces es mejor que esperes realmente esa cosa / evento. Mire las Variables de condición para esto.

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

Pasando ahora al otro extremo, si está tratando de esperar períodos excepcionalmente cortos, hay un par de opciones de estilo de pirateo. Si está trabajando en algún tipo de plataforma incrustada donde no se implementa un 'sueño', puede probar un bucle simple (for / 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, puede probar un ensamblaje "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.

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