c++ - milisegundos - funcion clock en c

Dormir por milisegundos

Question

Sé que la función de sleep(x) POSIX hace que el programa esté en espera durante x segundos. ¿Existe una función para hacer que el programa se duerma durante x milisegundos en C ++?

Answer 1

¿Por qué no usar la biblioteca time.h? Se ejecuta en sistemas Windows y POSIX:

#include <iostream>
#include <time.h>

using namespace std;

void sleepcp(int milliseconds);

void sleepcp(int milliseconds) // Cross-platform sleep function
{
    clock_t time_end;
    time_end = clock() + milliseconds * CLOCKS_PER_SEC/1000;
    while (clock() < time_end)
    {
    }
}
int main()
{
    cout << "Hi! At the count to 3, I''ll die! :)" << endl;
    sleepcp(3000);
    cout << "urrrrggghhhh!" << endl;
}

Código corregido: ahora la CPU permanece en estado IDLE [2014.05.24]:

#include <iostream>
#ifdef WIN32
    #include <windows.h>
#else
    #include <unistd.h>
#endif // win32

using namespace std;

void sleepcp(int milliseconds);

void sleepcp(int milliseconds) // Cross-platform sleep function
{
    #ifdef WIN32
        Sleep(milliseconds);
    #else
        usleep(milliseconds * 1000);
    #endif // win32
}
int main()
{
    cout << "Hi! At the count to 3, I''ll die! :)" << endl;
    sleepcp(3000);
    cout << "urrrrggghhhh!" << endl;
}

Answer 2

Como reemplazo de Win32 para los sistemas POSIX:

void Sleep(unsigned int milliseconds) {
    usleep(milliseconds * 1000);
}

while (1) {
    printf(".");
    Sleep((unsigned int)(1000.0f/20.0f)); // 20 fps
}

Answer 3

Dependiendo de su plataforma, puede tener usleep o nanosleep disponibles. usleep está en desuso y se ha eliminado del estándar POSIX más reciente; Se prefiere nanosleep .

Answer 4

En C ++ 11, puede hacer esto con las instalaciones de la biblioteca estándar:

#include <chrono>
#include <thread>

std::this_thread::sleep_for(std::chrono::milliseconds(x));

Claro y legible, ya no es necesario adivinar qué unidades toma la función sleep() .

Answer 5

En Unix puedes usar usleep .

En Windows hay Sleep .

Answer 6

En plataformas con la función de select (POSIX, Linux y Windows) podría hacer:

void sleep(unsigned long msec) {
    timeval delay = {msec / 1000, msec % 1000 * 1000};
    int rc = ::select(0, NULL, NULL, NULL, &delay);
    if(-1 == rc) {
        // Handle signals by continuing to sleep or return immediately.
    }
}

Sin embargo, hay mejores alternativas disponibles hoy en día.

Answer 7

La forma de dormir su programa en C ++ es el método Sleep(int) . El archivo de encabezado para él es #include "windows.h."

Por ejemplo:

#include "stdafx.h"
#include "windows.h"
#include "iostream"
using namespace std;

int main()
{
    int x = 6000;
    Sleep(x);
    cout << "6 seconds have passed" << endl;
    return 0;
}

El tiempo que duerme se mide en milisegundos y no tiene límite.

Second = 1000 milliseconds
Minute = 60000 milliseconds
Hour = 3600000 milliseconds

Answer 8

Para mantenerte portátil puedes usar Boost::Thread para dormir:

#include <boost/thread/thread.hpp>

int main()
{
    //waits 2 seconds
    boost::this_thread::sleep( boost::posix_time::seconds(1) );
    boost::this_thread::sleep( boost::posix_time::milliseconds(1000) );

    return 0;
}

Esta respuesta es un duplicado y se ha publicado en esta pregunta anteriormente. Quizás puedas encontrar algunas respuestas útiles allí también.

Answer 9

Seleccionar llamada es una forma de tener más precisión (el tiempo de suspensión se puede especificar en nanosegundos).

Answer 10

Si usa MS Visual C ++ 10.0, puede hacer esto con las instalaciones de la biblioteca estándar:

Concurrency::wait(milliseconds);

necesitará:

#include <concrt.h>

Answer 11

Tenga en cuenta que no hay una API estándar de C durante milisegundos, por lo que (en Unix) tendrá que conformarse con el usleep de usleep , que acepta microsegundos:

#include <unistd.h>

unsigned int microseconds;
...
usleep(microseconds);

Answer 12

Utilice los subprocesos de entrada / salida asíncronos Boost, suspensión durante x milisegundos;

#include <boost/thread.hpp>
#include <boost/asio.hpp>

boost::thread::sleep(boost::get_system_time() + boost::posix_time::millisec(1000));

Answer 13

nanosleep es una mejor opción que estar usleep , es más resistente a las interrupciones.

Answer 14

#include <WinBase.h>

Sintaxis:

Sleep (  __in DWORD dwMilliseconds   );

Uso:

Sleep (1000); //Sleeps for 1000 ms or 1 sec