Fonction Sleep en C++

Question

Existe-t-il une fonction comme Sleep(time); qui met le programme en pause pendant X millisecondes, mais en C++ ?

Quel en-tête dois-je ajouter et quelle est la signature de la fonction ?

Answer 1

Avant C++11, il n'y avait pas de moyen portable de le faire.

Un moyen portable consiste à utiliser Boost ou Ace bibliothèque. Il y a ACE_OS::sleep(); dans ACE.

Answer 2

La méthode la plus simple que j'ai trouvée pour C++ 11 était la suivante :

Votre comprend :

#include <chrono>
#include <thread>

Votre code (ceci est un exemple pour sleep 1000 milliseconde) :

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

La durée peut être configurée de l'une des manières suivantes :

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 3

Pour une solution courte, utilisez

#include <thread>

using namespace std;
using namespace std::this_thread;

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

Answer 4

Récemment, je me suis renseigné sur la bibliothèque chrono et j'ai pensé à implémenter une fonction de sommeil par moi-même. Voici le 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(); 
    }
}

Nous pouvons l'utiliser avec n'importe quel std::chrono::duration (Par défaut, il prend std::chrono::seconds comme argument). Par exemple,

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

Pour plus d'informations, visitez https://en.cppreference.com/w/cpp/header/chrono et voir ce discours à la cppcon de Howard Hinnant , https://www.youtube.com/watch?v=P32hvk8b13M . Il a deux autres conférences sur la bibliothèque chrono. Et vous pouvez toujours utiliser la fonction de bibliothèque, std::this_thread::sleep_for

Note : Les résultats peuvent ne pas être exacts. Ne vous attendez donc pas à ce qu'il donne des temps exacts.

Answer 5

J'aime la solution proposée par @Ben Voigt -- elle ne repose sur rien d'autre que le C++, mais il n'a pas mentionné un détail important pour que le code fonctionne. Je mets donc le code complet, veuillez noter la ligne commençant par using.

#include <thread>
#include <chrono>

...

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