Ngủ trong một phần nghìn giây

Tôi biết sleep(x)chức năng POSIX làm cho chương trình ngủ trong x giây. Có một chức năng để làm cho chương trình ngủ trong x mili giây trong C ++ không?

Lưu ý rằng không có API C tiêu chuẩn cho mili giây, vì vậy (trên Unix) bạn sẽ phải giải quyết usleep, chấp nhận micro giây:

#include <unistd.h>

unsigned int microseconds;
...
usleep(microseconds);

Trong C ++ 11, bạn có thể làm điều này với các cơ sở thư viện tiêu chuẩn:

#include <chrono>
#include <thread>

std::this_thread::sleep_for(std::chrono::milliseconds(x));

Rõ ràng và có thể đọc được, không cần phải đoán đơn vị nào mà sleep()hàm thực hiện.

Để luôn di động, bạn có thể sử dụng Boost :: Thread để ngủ:

#include <boost/thread/thread.hpp>

int main()
{
    //waits 2 seconds
    boost::this_thread::sleep( boost::posix_time::seconds(1) );
    boost::this_thread::sleep( boost::posix_time::milliseconds(1000) );

    return 0;
}

Câu trả lời này là một bản sao và đã được đăng trong câu hỏi này trước đây. Có lẽ bạn có thể tìm thấy một số câu trả lời có thể sử dụng ở đó quá.

Trong Unix bạn có thể sử dụng us ngủ .

Trong Windows có chế độ Ngủ .

Tùy thuộc vào nền tảng của bạn, bạn có thể có usleephoặc nanosleepcó sẵn. usleepkhông được chấp nhận và đã bị xóa khỏi tiêu chuẩn POSIX gần đây nhất; nanosleepđược ưa thích.

Tại sao không sử dụng thư viện time.h? Chạy trên hệ thống Windows và POSIX:

#include <iostream>
#include <time.h>

using namespace std;

void sleepcp(int milliseconds);

void sleepcp(int milliseconds) // Cross-platform sleep function
{
    clock_t time_end;
    time_end = clock() + milliseconds * CLOCKS_PER_SEC/1000;
    while (clock() < time_end)
    {
    }
}
int main()
{
    cout << "Hi! At the count to 3, I'll die! :)" << endl;
    sleepcp(3000);
    cout << "urrrrggghhhh!" << endl;
}

Mã đã sửa - hiện CPU vẫn ở trạng thái IDLE [2014.05.24]:

#include <iostream>
#ifdef _WIN32
    #include <windows.h>
#else
    #include <unistd.h>
#endif // _WIN32

using namespace std;

void sleepcp(int milliseconds);

void sleepcp(int milliseconds) // Cross-platform sleep function
{
    #ifdef _WIN32
        Sleep(milliseconds);
    #else
        usleep(milliseconds * 1000);
    #endif // _WIN32
}
int main()
{
    cout << "Hi! At the count to 3, I'll die! :)" << endl;
    sleepcp(3000);
    cout << "urrrrggghhhh!" << endl;
}

nanosleeplà một lựa chọn tốt hơn usleep- nó kiên cường hơn trước các ngắt.

#include <windows.h>

Cú pháp:

Sleep (  __in DWORD dwMilliseconds   );

Sử dụng:

Sleep (1000); //Sleeps for 1000 ms or 1 sec

Nếu sử dụng MS Visual C ++ 10.0, bạn có thể thực hiện việc này với các tiện ích thư viện tiêu chuẩn:

Concurrency::wait(milliseconds);

bạn sẽ cần:

#include <concrt.h>

Trên các nền tảng có selectchức năng (POSIX, Linux và Windows) bạn có thể làm:

void sleep(unsigned long msec) {
    timeval delay = {msec / 1000, msec % 1000 * 1000};
    int rc = ::select(0, NULL, NULL, NULL, &delay);
    if(-1 == rc) {
        // Handle signals by continuing to sleep or return immediately.
    }
}

Tuy nhiên, có những lựa chọn thay thế tốt hơn hiện nay.

Cách để ngủ chương trình của bạn trong C ++ là Sleep(int)phương pháp. Các tập tin tiêu đề cho nó là#include "windows.h."

Ví dụ:

#include "stdafx.h"
#include "windows.h"
#include "iostream"
using namespace std;

int main()
{
    int x = 6000;
    Sleep(x);
    cout << "6 seconds have passed" << endl;
    return 0;
}

Thời gian nó ngủ được đo bằng mili giây và không có giới hạn.

Second = 1000 milliseconds
Minute = 60000 milliseconds
Hour = 3600000 milliseconds

Chọn cuộc gọi là cách để có độ chính xác cao hơn (thời gian ngủ có thể được chỉ định bằng nano giây).

Sử dụng các luồng đầu vào / đầu ra không đồng bộ Boost, ngủ trong x mili giây;

#include <boost/thread.hpp>
#include <boost/asio.hpp>

boost::thread::sleep(boost::get_system_time() + boost::posix_time::millisec(1000));

Câu hỏi đã cũ, nhưng tôi đã tìm ra một cách đơn giản để có điều này trong ứng dụng của mình. Bạn có thể tạo một macro C / C ++ như bên dưới sử dụng nó:

#ifndef MACROS_H
#define MACROS_H

#include <unistd.h>

#define msleep(X) usleep(X * 1000)

#endif // MACROS_H

Từ C ++ 14 bằng cách sử dụng tiêu chuẩn và cả chữ số của nó:

#include <chrono>
#include <thread>

using namespace std::chrono;

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

Là một thay thế Win32 cho các hệ thống POSIX:

void Sleep(unsigned int milliseconds) {
    usleep(milliseconds * 1000);
}

while (1) {
    printf(".");
    Sleep((unsigned int)(1000.0f/20.0f)); // 20 fps
}