Кросс-платформенная функция Sleep для С++

Ответ 1

Да, есть. То, что вы делаете, - это перенос различных системных вызовов сна в вашу собственную функцию, а также операторов include, как показано ниже:

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

Затем ваш код вызывает mySleep для сна, а не для прямых системных вызовов.

Ответ 2

Угу. Но это работает только в С++ 11 и позже.

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

где ms - количество времени, которое вы хотите спать в миллисекундах.

Вы также можете заменить milliseconds на nanoseconds, microseconds, seconds, minutes или hours. (Это специализации типа std:: chrono:: duration.)

Обновление: В С++ 14, если вы спите в течение определенного времени, для экземпляр 100 миллисекунд, std::chrono::milliseconds(100) может быть записан как 100ms. Это связано с пользовательскими литералами, которые были введены в С++ 11. В С++ 14 библиотека chrono была расширена, чтобы включить следующие пользовательские литералы:

• 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

Эффективно это означает, что вы можете написать что-то вроде этого.

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

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

Обратите внимание, что хотя using namespace std::literals::chrono_literals обеспечивает наименьшее количество загрязнений пространства имен, эти операторы также доступны, когда using namespace std::literals или using namespace std::chrono.

Ответ 3

shf301 имел хорошую идею, но этот способ лучше:

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

Затем используйте так:

Sleep(how_many_milliseconds);

Ответ 4

Получить Boost.

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

Ответ 5

Исходным решением является вызов select() (требуется Winsock). Этот конкретный вызов имеет точно такое же поведение в Linux и 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);

Ответ 6

В linux помните, что у usleep есть предел. Вы не можете "спать" более 1000 секунд.

Я бы написал так:

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

Ответ 7

Просто сделай

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

Это проверяет текущее время (в миллисекундах), вычитает из него время начала, которое дает время, используемое функцией. Если это число меньше критического значения (целевой временной длины), то оно ничего не делает, убивая небольшое количество времени. Это повторяется до тех пор, пока время не превысит критическое значение, а затем остановится.

РЕДАКТИРОВАТЬ: ошибки с фиксированным кодом