Кросс-платформа Функция сна для C++

Question

Возможно ли с помощью макросов сделать кросс-платформенный код сна? Например

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

Answer 1

Да, есть. Что вы делаете это обернуть другую система спит вызовы в своей собственной функции, а также включают в себя такие заявления ниже:

#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 спать, а не делать прямые системные вызовы.

Answer 2

Получить 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

Исходное решение - вызов 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); 

Answer 4

В 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); 

Answer 5

Угу. Но это работает только в C++11 и later.

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

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

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

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

• 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 обеспечивает наименьшее количество namespace pollution, эти операторы также доступны, когда using namespace std::literals или using namespace std::chrono.

Answer 6

shf301 была хорошая идея, но этот путь лучше:

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

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

Sleep(how_many_milliseconds); 

Answer 7

Вобще

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

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

EDIT: фиксированный код ошибки