Sleep function in C++ - c++

Question

Is there a function like Sleep(time); that pauses the program for X milliseconds, but in C++?
Which header should I add and what is the function's signature?

Answer 1

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.

Answer 2

You'll need at least C++11.
#include <thread>
#include <chrono>
...
std::this_thread::sleep_for(std::chrono::milliseconds(200));

Answer 3

For Windows:
#include "windows.h"
Sleep(10);
For Unix:
#include <unistd.h>
usleep(10)

Answer 4

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

Answer 5

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

Answer 6

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.

Answer 7

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

Answer 8

For a short solution use
#include <thread>
using namespace std;
using namespace std::this_thread;
void f() {
sleep_for(200ms);
}

Answer 9

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.

Answer 10

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