web-dev-qa-db-fra.com

Fonction de veille multiplateforme pour C ++

Est-il possible avec des macros de faire du code Sleep multiplateforme? Par exemple

#ifdef LINUX
#include <header_for_linux_sleep_function.h>
#endif
#ifdef WINDOWS
#include <header_for_windows_sleep_function.h>
#endif
...
Sleep(miliseconds);
...
c++cross-platformsleep
35
ElSajko

Oui il y a. Ce que vous faites, c'est encapsuler les différents appels système en veille dans votre propre fonction ainsi que les instructions include comme ci-dessous:

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

Ensuite, votre code appelle mySleep en veille plutôt que de passer des appels système directs.

41
shf301

Ouaip. Mais cela ne fonctionne qu'en C++ 11 et plus tard .

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

où ms est la durée de sommeil en millisecondes.

Vous pouvez également remplacer milliseconds par nanoseconds, microseconds, seconds, minutes ou hours. (Ce sont des spécialisations du type std :: chrono :: duration .)

Mise à jour: Dans C++ 14 , si vous dormez pendant un certain temps, par exemple 100 millisecondes, std::chrono::milliseconds(100) peut s'écrire comme 100ms. Cela est dû à littéraux définis par l'utilisateur , qui ont été introduits dans C++ 11 . Dans C++ 14 la bibliothèque chrono a été étendue pour inclure les littéraux définis par l'utilisateur suivants:

En fait, cela signifie que vous pouvez écrire quelque chose comme ça.

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

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

Notez que, alors que using namespace std::literals::chrono_literals Fournit le moins de pollution de l'espace de noms , ces opérateurs sont également disponibles lorsque using namespace std::literals Ou using namespace std::chrono.

60
Michael Dorst

shf301 a eu une bonne idée, mais c'est mieux ainsi:

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

Ensuite, utilisez comme ceci:

Sleep(how_many_milliseconds);
22
Dženan

Obtenez Boost .

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

La solution de base est l'appel select () (nécessite Winsock). Cet appel particulier a exactement le même comportement sous Linux et 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);
8
Joshua

Sous Linux, n'oubliez pas que l'usep a une limite. Vous ne pouvez pas "dormir" plus de 1000 secondes.

J'écrirais comme ça

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