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

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à dễ đọc, không cần phải đoán đơn vị nào mà hàm sleep() thực hiện.

Để duy trì khả năng 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 đó. Có lẽ bạn có thể tìm thấy một số câu trả lời có thể sử dụng ở đó quá.

Tùy thuộc vào nền tảng của bạn, bạn có thể có sẵn usleep hoặc nanosleep. usleep khô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.

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

Trong Windows có Ngủ .

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

nanosleep là một lựa chọn tốt hơn usleep - nó có khả năng phục hồi tốt 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 chuẩn:

Concurrency::wait(milliseconds);

bạn sẽ cần:

#include <concrt.h>

Cách để ngủ chương trình của bạn trong C++ là phương thức Sleep(int). Tệp 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

Sử dụng Boost luồng đầu vào/đầu ra không đồng bộ, 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));

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).

Trên các nền tảng có chức năng select (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.

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
}

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