c++ - milisegundos - funcion clock en c
Dormir por milisegundos (14)
¿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;
}
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 ++?
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
}
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 .
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() .
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.
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
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.
Seleccionar llamada es una forma de tener más precisión (el tiempo de suspensión se puede especificar en nanosegundos).
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>
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);
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));
nanosleep es una mejor opción que estar usleep , es más resistente a las interrupciones.
#include <WinBase.h>
Sintaxis:
Sleep ( __in DWORD dwMilliseconds );
Uso:
Sleep (1000); //Sleeps for 1000 ms or 1 sec