Schlaffunktion in C ++

Gibt es eine Sleep(time);solche Funktion , die das Programm für X Millisekunden anhält, aber in C ++?

Welchen Header soll ich hinzufügen und wie lautet die Signatur der Funktion?

Verwendung std::this_thread::sleep_for:

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

std::this_thread::sleep_for(timespan);

Es gibt auch die Ergänzung std::this_thread::sleep_until.

Vor C ++ 11 hatte C ++ kein Thread-Konzept und keine Sleep-Fähigkeit, sodass Ihre Lösung notwendigerweise plattformabhängig war. Hier ist ein Ausschnitt, der eine sleepFunktion für Windows oder Unix definiert:

#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

Es ist jedoch eine viel einfachere Methode vor C ++ 11 zu verwenden boost::this_thread::sleep.

Sie benötigen mindestens C ++ 11.

#include <thread>
#include <chrono>

...

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

Unter Unix einschließen #include <unistd.h>.

Der Anruf, an dem Sie interessiert sind, ist usleep(). Was Mikrosekunden dauert, also sollten Sie Ihren Millisekundenwert mit 1000 multiplizieren und das Ergebnis an übergeben usleep().

Für Windows:

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

Für Unix:

#include <unistd.h>
usleep(10)

Benutze es einfach ...

Fügen Sie zunächst die unistd.hHeader-Datei hinzu #include<unistd.h>und verwenden Sie diese Funktion, um die Programmausführung für die gewünschte Anzahl von Sekunden anzuhalten:

sleep(x);

x kann in Sekunden einen beliebigen Wert annehmen.

Wenn Sie das Programm für 5 Sekunden anhalten möchten, ist dies wie folgt:

sleep(5);

Es ist richtig und ich benutze es häufig.

Es gilt für C und C ++.

Vor C ++ 11 gab es keine tragbare Möglichkeit, dies zu tun.

Eine tragbare Möglichkeit ist die Verwendung der Boost- oder Ace- Bibliothek. Es gibt ACE_OS::sleep();in ACE.

Der einfachste Weg, den ich für C ++ 11 gefunden habe, war folgender:

Ihr beinhaltet:

#include <chrono>
#include <thread>

Ihr Code (dies ist ein Beispiel für den Schlaf 1000 Millisekunden):

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

Die Dauer kann wie folgt konfiguriert werden:

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