C + + 中的睡眠函数

For Windows:

#include "windows.h"
Sleep(10);

For Unix:

#include <unistd.h>
usleep(10)

Prior to C++11, there was no portable way to do this.

A portable way is to use Boost or Ace library. There is ACE_OS::sleep(); in ACE.

On Unix, include #include <unistd.h>.

The call you're interested in is usleep(). Which takes microseconds, so you should multiply your millisecond value by 1000 and pass the result to usleep().

Use std::this_thread::sleep_for:

#include <chrono>
#include <thread>


std::chrono::milliseconds timespan(111605); // or whatever


std::this_thread::sleep_for(timespan);

There is also the complementary std::this_thread::sleep_until.

Prior to C++11, C++ had no thread concept and no sleep capability, so your solution was necessarily platform dependent. Here's a snippet that defines a sleep function for Windows or Unix:

#ifdef _WIN32
#include <windows.h>


void sleep(unsigned milliseconds)
{
Sleep(milliseconds);
}
#else
#include <unistd.h>
    

void sleep(unsigned milliseconds)
{
usleep(milliseconds * 1000); // takes microseconds
}
#endif

But a much simpler pre-C++11 method is to use boost::this_thread::sleep.

The simplest way I found for C++ 11 was this:

Your includes:

#include <chrono>
#include <thread>

Your code (this is an example for sleep 1000 millisecond):

std::chrono::duration<int, std::milli> timespan(1000);
std::this_thread::sleep_for(timespan);

The duration could be configured to any of the following:

std::chrono::nanoseconds   duration</*signed integer type of at least 64 bits*/, std::nano>
std::chrono::microseconds  duration</*signed integer type of at least 55 bits*/, std::micro>
std::chrono::milliseconds  duration</*signed integer type of at least 45 bits*/, std::milli>
std::chrono::seconds       duration</*signed integer type of at least 35 bits*/, std::ratio<1>>
std::chrono::minutes       duration</*signed integer type of at least 29 bits*/, std::ratio<60>>
std::chrono::hours         duration</*signed integer type of at least 23 bits*/, std::ratio<3600>>

You'll need at least C++11.

#include <thread>
#include <chrono>


...


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

Just use it...

Firstly include the unistd.h header file, #include<unistd.h>, and use this function for pausing your program execution for desired number of seconds:

sleep(x);

x can take any value in seconds.

If you want to pause the program for 5 seconds it is like this:

sleep(5);

It is correct and I use it frequently.

It is valid for C and C++.

Recently I was learning about chrono library and thought of implementing a sleep function on my own. Here is the code,

#include <cmath>
#include <chrono>


template <typename rep = std::chrono::seconds::rep,
typename period = std::chrono::seconds::period>
void sleep(std::chrono::duration<rep, period> sec)
{
using sleep_duration = std::chrono::duration<long double, std::nano>;


std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();


long double elapsed_time =
std::chrono::duration_cast<sleep_duration>(end - start).count();


long double sleep_time =
std::chrono::duration_cast<sleep_duration>(sec).count();


while (std::isgreater(sleep_time, elapsed_time)) {
end = std::chrono::steady_clock::now();
elapsed_time = std::chrono::duration_cast<sleep_duration>(end - start).count();
}
}

We can use it with any std::chrono::duration type (By default it takes std::chrono::seconds as argument). For example,

#include <cmath>
#include <chrono>


template <typename rep = std::chrono::seconds::rep,
typename period = std::chrono::seconds::period>
void sleep(std::chrono::duration<rep, period> sec)
{
using sleep_duration = std::chrono::duration<long double, std::nano>;


std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();


long double elapsed_time =
std::chrono::duration_cast<sleep_duration>(end - start).count();


long double sleep_time =
std::chrono::duration_cast<sleep_duration>(sec).count();


while (std::isgreater(sleep_time, elapsed_time)) {
end = std::chrono::steady_clock::now();
elapsed_time = std::chrono::duration_cast<sleep_duration>(end - start).count();
}
}


using namespace std::chrono_literals;
int main (void) {
std::chrono::steady_clock::time_point start1 = std::chrono::steady_clock::now();
    

sleep(5s);  // sleep for 5 seconds
    

std::chrono::steady_clock::time_point end1 = std::chrono::steady_clock::now();
    

std::cout << std::setprecision(9) << std::fixed;
std::cout << "Elapsed time was: " << std::chrono::duration_cast<std::chrono::seconds>(end1-start1).count() << "s\n";
    

std::chrono::steady_clock::time_point start2 = std::chrono::steady_clock::now();


sleep(500000ns);  // sleep for 500000 nano seconds/500 micro seconds
// same as writing: sleep(500us)
    

std::chrono::steady_clock::time_point end2 = std::chrono::steady_clock::now();
    

std::cout << "Elapsed time was: " << std::chrono::duration_cast<std::chrono::microseconds>(end2-start2).count() << "us\n";
return 0;
}

For more information, visit https://en.cppreference.com/w/cpp/header/chrono and see this cppcon talk of Howard Hinnant, https://www.youtube.com/watch?v=P32hvk8b13M. He has two more talks on chrono library. And you can always use the library function, std::this_thread::sleep_for

Note: Outputs may not be accurate. So, don't expect it to give exact timings.

I like the solution proposed by @Ben Voigt -- it does not rely on anything outside of C++, but he did not mention an important detail to make the code work. So I am putting the full code, please notice the line starting with using.

#include <thread>
#include <chrono>


...


using namespace std::chrono_literals;
std::this_thread::sleep_for(200ms);

For a short solution use

#include <thread>


using namespace std;
using namespace std::this_thread;


void f() {
sleep_for(200ms);
}