Cross-Plattform-Sleep-Funktion für C++

Question

Ist es möglich mit Makros Cross-Plattform-Sleep-Code machen? Zum Beispiel

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

Answer 1

Ja, gibt es. Was Sie tun das andere System schläft Anrufe in Ihrer eigenen Funktion wickeln sowie die beinhalten Aussagen wie unten:

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

Dann wird Ihr Code ruft mySleep eher zu schlafen, als direkte System Anrufe.

Answer 2

Boost Holen.

#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

Die Standardlösung ist der Aufruf select() (erfordert Winsock). Dieser bestimmte Aufruf hat genau das gleiche Verhalten unter Linux und 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

In linux erinnern, dass usleep hat ein Limit. Sie können nicht mehr als 1000 Sekunden "schlafen".

möchte ich diese

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

Yup schreiben. Aber das funktioniert nur in C++11 und later.

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

wo ms ist die Menge an Zeit, die Sie in Millisekunden schlafen wollen.

können Sie auch milliseconds mit nanoseconds, microseconds, seconds, minutes oder hours ersetzen. (Dies sind Spezialisierungen des Typs std::chrono::duration.)

Update: In C++14, wenn Sie sich für eine bestimmte Zeit schlafen, zum Beispiel 100 Millisekunden, kann std::chrono::milliseconds(100) als 100ms geschrieben werden. Dies liegt an user defined literals, die in C++11 eingeführt wurden. In C++14 hat die chrono Bibliothek erweitert die folgenden benutzerdefinierten Literale enthalten:

• 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

Effektiv bedeutet dies, dass Sie so etwas schreiben können.

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

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

Beachten Sie, dass, während using namespace std::literals::chrono_literals die geringste Menge an namespace pollution bietet, sind diese Betreiber auch zur Verfügung, wenn using namespace std::literals oder using namespace std::chrono.

Answer 6

shf301 hatte eine gute Idee, aber diese Art und Weise ist besser:

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

Dann wie folgt verwenden:

Sleep(how_many_milliseconds); 

Answer 7

Just do

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

, dass die aktuelle Zeit überprüft (in Millisekunden), subtrahiert die Startzeit von ihm, was die von der Funktion benötigte Zeit ergibt. Wenn diese Zahl kleiner ist als der kritische Wert (Zielzeitlänge), dann tut sie nichts und tötet eine kleine Menge an Zeit. Das wiederholt sich, bis die Zeit den kritischen Wert überschreitet, wo es dann aufhört.

EDIT: Festcode Fehler