Función de suspensión de plataforma cruzada para C++

Question

¿Es posible con las macros hacer el código de plataforma cruzada? Por ejemplo

#ifdef LINUX 
#include <header_for_linux_sleep_function.h> 
#endif 
#ifdef WINDOWS 
#include <header_for_windows_sleep_function.h> 
#endif 
... 
Sleep(miliseconds); 
... 

Answer 1

Sí, hay. Lo que se hace es envolver el diferente sistema de llamadas duerme en su propia función, así como las declaraciones como incluir a continuación:

#ifdef LINUX 
#include <unistd.h> 
#endif 
#ifdef WINDOWS 
#include <windows.h> 
#endif 

void mySleep(int sleepMs) 
{ 
#ifdef LINUX 
    usleep(sleepMs * 1000); // usleep takes sleep time in us (1 millionth of a second) 
#endif 
#ifdef WINDOWS 
    Sleep(sleepMs); 
#endif 
} 

A continuación, el código llama mySleep a dormir en lugar de hacer llamadas al sistema directos.

Answer 2

Get Boost.

#include <boost/thread/thread.hpp> 
#include <boost/date_time/posix_time/posix_time.hpp> 
... 
boost::this_thread::sleep(boost::posix_time::millisec(milliseconds)); 

Answer 3

La solución estándar es la llamada select() (requiere Winsock). Esta llamada en particular tiene exactamente el mismo comportamiento en Linux y Windows.

long value; /* time in microseconds */ 

struct timeval tv; 
tv.tv_sec = value/1000000; 
tv.tv_usec = value % 1000000; 
select(0, NULL, NULL, NULL, &tf); 

Answer 4

En linux recuerda que usleep tiene un límite. No puede 'dormir' más de 1000 segundos.

que iba a escribir como esto

struct timespec req={0},rem={0}; 
req.tv_sec=(milisec/1000); 
req.tv_nsec=(milisec - req.tv_sec*1000)*1000000; 
nanosleep(&req,&rem); 

Answer 5

Sip. Pero esto solo funciona en C++11 y later.

#include <chrono> 
#include <thread> 
... 
std::this_thread::sleep_for(std::chrono::milliseconds(ms)); 

donde ms es la cantidad de tiempo que desea dormir en milisegundos.

También puede reemplazar con millisecondsnanoseconds, microseconds, seconds, minutes o hours. (Estos son especializaciones del tipo std::chrono::duration.)

Actualización: En C++14, si usted está durmiendo por una cantidad fija de tiempo, por ejemplo, 100 milisegundos, std::chrono::milliseconds(100) se puede escribir como 100ms. Esto se debe a user defined literals, que se introdujeron en C++11. En C++14 la biblioteca chrono se ha ampliado para incluir los siguientes definidos por el usuario literales:

• std::literals::chrono_literals::operator""h
• std::literals::chrono_literals::operator""min
• std::literals::chrono_literals::operator""s
• std::literals::chrono_literals::operator""ms
• std::literals::chrono_literals::operator""us
• std::literals::chrono_literals::operator""ns

Efectivamente, esto significa que puede escribir algo como esto.

#include <chrono> 
#include <thread> 
using namespace std::literals::chrono_literals; 

std::this_thread::sleep_for(100ms); 

Tenga en cuenta que, mientras que using namespace std::literals::chrono_literals proporciona la menor cantidad de namespace pollution, estos operadores también están disponibles cuando using namespace std::literals, o using namespace std::chrono.

Answer 6

shf301 tenía una buena idea, pero de esta manera es mejor:

#ifdef _WINDOWS 
#include <windows.h> 
#else 
#include <unistd.h> 
#define Sleep(x) usleep((x)*1000) 
#endif 

A continuación, utilice la siguiente manera:

Sleep(how_many_milliseconds); 

Answer 7

Sólo hacer

#include <ctime> 
int Sleep(int ms) 
{ 
    clock_t starting = clock(); 
    while(clock() - starting < ms) {} 
    return 0; 
} 

que comprueba la hora actual (en milisegundos), resta el tiempo de inicio de la misma, lo que da la cantidad de tiempo utilizada por la función. Si ese número es menor que el valor crítico (longitud de tiempo objetivo), entonces no hace nada, matando una pequeña cantidad de tiempo. Eso se repite hasta que el tiempo excede el valor crítico, donde se detiene.

EDIT: fija los errores de código