Couchage pour millisecondes sur Windows, Linux, Solaris, HP-UX, IBM AIX, Vxworks, Wind River Linux?

Probablement une enveloppe à l'aide de la plate-forme #defines effectuera:

#if defined(WIN32)
  #include <windows.h>
#elif defined(__UNIX__)
  #include <unistd.h>
#else
#endif

...

int millisleep(unsigned ms)
{
#if defined(WIN32)
  SetLastError(0);
  Sleep(ms);
  return GetLastError() ?-1 :0;
#elif defined(LINUX)
  return usleep(1000 * ms);
#else
#error ("no milli sleep available for platform")
  return -1;
#endif
}

---

Mise à jour

Se référant à Jonathan commentaire ci-dessous, s'il vous plaît trouver un plus moderne, plus portable (et ainsi corrigé :}) version ici:

#if defined(WIN32)
  #include <windows.h>
#elif defined(__unix__)
  #include <time.h>
  #include <unistd.h>
#else
#endif

...

int millisleep(unsigned ms)
{
#if defined(WIN32)

  SetLastError(0);
  Sleep(ms);
  return GetLastError() ?-1 :0;

#elif _POSIX_C_SOURCE >= 199309L

  /* prefer to use nanosleep() */

  const struct timespec ts = {
    ms / 1000, /* seconds */
    (ms % 1000) * 1000 * 1000 /* nano seconds */
  };

  return nanosleep(&ts, NULL);

#elif _BSD_SOURCE || \
  (_XOPEN_SOURCE >= 500 || \
     _XOPEN_SOURCE && _XOPEN_SOURCE_EXTENDED) && \
  !(_POSIX_C_SOURCE >= 200809L || _XOPEN_SOURCE >= 700)

  /* else fallback to obsolte usleep() */

  return usleep(1000 * ms);

#else

# error ("No millisecond sleep available for this platform!")
  return -1;

#endif
}

OriginalL'auteur alk

Je remarque que usleep est vieillissante, mais c'est beaucoup plus simple que nanosleep. Donc je l'ai utilisé quand j'ai besoin d'un renforcement de sommeil qui permettrait à l'ajustement facile de secondes pendant le débogage de mes scripts de millisecondes ou zéro pour la production.

Cette fonction de rappel d'alarme combine les avantages de sommeil & usleep de sorte que vous pouvez
entrez un int ou un float pour sélectionner votre retard et de 0,1 va dormir un 10ème de
une seconde pendant 3 va dormir pendant 3 secondes. 3.5 secondes est traité en tant que 3 secondes.

Testé sur Linux Mint 18.3 (Ubuntu 16.04.9) comme le C et le C++ avec gcc 5.4.0.

#include <unistd.h>

void snooze(double t) {(t > 1.0) ? sleep(t) : usleep(t*1000000);}

snooze(0.01);  //call function to sleep for 10ms

---

Pour être complet, c'est un nanosleep version. C'est potentiellement plus précise que la usleep version et n'est pas menacé d'obsolescence.

#include <time.h>
#include <math.h>

void snooze(double t) {
    struct timespec req = {t, fmod(t, 1.0) * 1E9};
    nanosleep(&req, NULL);
}

//struct timespec req = {t, fmod(t, 1.0) * 1E9};
// is equivalent to:
//struct timespec req = {0};
//req.tv_sec = t;
//req.tv_nsec = fmod(t, 1.0) * 1000000000L;

//NULL as value for *rem so no resumption after signal interrupts

snooze(1.99);  //call for delay of 1.99 seconds

---

Comme suggéré par @alk, les versions suivantes de retour de la appelé le sommeil de la fonction d'erreur doit avoir un lieu ou 0 en cas de succès. La définition de la structure de rem(aining) permet également à une reprise après un signal d'interruption.

int snooze(double t) {
    return (t > 1.0) ? sleep(t) : usleep(t*1000000);
}

int snooze(double t) {
    struct timespec req = {t, fmod(t, 1.0) * 1E9};
    struct timespec rem = {0, 0.0};
    return nanosleep(&req, &rem);
}

OriginalL'auteur John 9631