Wie fügt man einem C ++ - Programm eine zeitgesteuerte Verzögerung hinzu?

Ich versuche, eine zeitgesteuerte Verzögerung in ein C ++ - Programm einzufügen, und habe mich gefragt, ob jemand Vorschläge dazu hat, was ich versuchen kann, oder Informationen, die ich mir ansehen kann.

Ich wünschte, ich hätte mehr Details darüber, wie ich diese zeitgesteuerte Verzögerung implementiere, aber bis ich weitere Informationen zum Hinzufügen einer zeitgesteuerten Verzögerung habe, bin ich mir nicht sicher, wie ich überhaupt versuchen soll, dies zu implementieren.

Win32: Sleep(milliseconds)ist was du was

Unix: usleep(microseconds)ist was du willst.

sleep () dauert nur einige Sekunden, was oft zu lang ist.

Eine aktualisierte Antwort für C ++ 11:

Verwenden Sie die sleep_forund sleep_untilFunktionen:

#include <chrono>
#include <thread>

int main() {
    using namespace std::this_thread; // sleep_for, sleep_until
    using namespace std::chrono; // nanoseconds, system_clock, seconds

    sleep_for(nanoseconds(10));
    sleep_until(system_clock::now() + seconds(1));
}

Mit diesen Funktionen ist es nicht mehr notwendig , um immer wieder neue Funktionen für eine bessere Auflösung hinzuzufügen: sleep, usleep, nanosleepusw. sleep_forund sleep_untilsind Template - Funktionen , die Werte einer beliebigen Auflösung über akzeptieren chronoTypen; Stunden, Sekunden, Femtosekunden usw.

In C ++ 14 können Sie den Code mit den Literal-Suffixen für nanosecondsund weiter vereinfachen seconds:

#include <chrono>
#include <thread>

int main() {
    using namespace std::this_thread;     // sleep_for, sleep_until
    using namespace std::chrono_literals; // ns, us, ms, s, h, etc.
    using std::chrono::system_clock;

    sleep_for(10ns);
    sleep_until(system_clock::now() + 1s);
}

Beachten Sie, dass die tatsächliche Dauer eines Ruhezustands von der Implementierung abhängt: Sie können 10 Nanosekunden lang nach dem Ruhezustand fragen. Eine Implementierung kann jedoch stattdessen eine Millisekunde lang schlafen, wenn dies die kürzeste Zeit ist, die sie ausführen kann.

#include <unistd.h>
usleep(3000000);

Dies wird auch für drei Sekunden schlafen. Sie können die Zahlen jedoch etwas weiter verfeinern.

Willst du etwas so Einfaches wie

sleep(3);

Beachten Sie, dass dies nicht garantiert, dass die Ruhezeit des Threads irgendwo in der Nähe der Ruhezeit liegt, sondern nur, dass die Zeitspanne, bevor der Thread die Ausführung fortsetzt, mindestens die gewünschte Zeitspanne beträgt. Die tatsächliche Verzögerung hängt von den Umständen ab (insbesondere von der Belastung der betreffenden Maschine) und kann um Größenordnungen höher sein als die gewünschte Ruhezeit.

Außerdem geben Sie nicht an, warum Sie schlafen müssen, aber Sie sollten generell vermeiden, Verzögerungen als Synchronisationsmethode zu verwenden.

Sie können dieses Code-Snippet ausprobieren:

#include<chrono>
#include<thread>

int main(){
    std::this_thread::sleep_for(std::chrono::nanoseconds(10));
    std::this_thread::sleep_until(std::chrono::system_clock::now() + std::chrono::seconds(1));
}

Sie können auch select (2) verwenden, wenn Sie eine Mikrosekundengenauigkeit wünschen (dies funktioniert auf Plattformen ohne Usleep (3)).

Der folgende Code wartet 1,5 Sekunden:

#include <sys/select.h>
#include <sys/time.h>
#include <unistd.h>`

int main() {
    struct timeval t;
    t.tv_sec = 1;
    t.tv_usec = 500000;
    select(0, NULL, NULL, NULL, &t);
}

`

Ja, Schlaf ist hier wahrscheinlich die Funktion der Wahl. Beachten Sie, dass die in die Funktion verstrichene Zeit die kleinste Zeit ist, in der der aufrufende Thread inaktiv ist. Wenn Sie beispielsweise den Ruhezustand mit 5 Sekunden aufrufen, ist Ihr Thread garantiert mindestens 5 Sekunden lang im Ruhezustand. Kann 6, 8 oder 50 sein, je nachdem, was das Betriebssystem tut. (Während der optimalen Ausführung des Betriebssystems liegt dies sehr nahe bei 5.)
Eine weitere nützliche Funktion der Sleep-Funktion ist die Übergabe von 0. Dadurch wird ein Kontextwechsel von Ihrem Thread erzwungen.

Einige zusätzliche Informationen:
http://www.opengroup.org/onlinepubs/000095399/functions/sleep.html

Ich fand, dass "_sleep(milliseconds);"(ohne die Anführungszeichen) gut für Win32 funktioniert, wenn Sie die chronoBibliothek einschließen

Z.B:

#include <chrono>

using namespace std;

main
{
    cout << "text" << endl;
    _sleep(10000); // pauses for 10 seconds
}

Stellen Sie sicher, dass Sie den Unterstrich vor dem Schlafengehen einfügen.

Um die Ausgabe in cpp für eine feste Zeit zu verzögern, können Sie die Sleep () - Funktion verwenden, indem Sie die Windows.h-Header-Dateisyntax für die Sleep () - Funktion in Sleep (time_in_ms) as einfügen

cout<<"Apple\n";
Sleep(3000);
cout<<"Mango";

AUSGABE. Der obige Code druckt Apple und wartet 3 Sekunden, bevor Mango gedruckt wird.

Die beste Antwort hier scheint eine betriebssystemabhängige Antwort zu sein. Für eine portablere Lösung können Sie mithilfe der ctime-Headerdatei eine Schnellschlaffunktion erstellen (obwohl dies möglicherweise eine schlechte Implementierung meinerseits ist).

#include <iostream>
#include <ctime>

using namespace std;

void sleep(float seconds){
    clock_t startClock = clock();
    float secondsAhead = seconds * CLOCKS_PER_SEC;
    // do nothing until the elapsed time has passed.
    while(clock() < startClock+secondsAhead);
    return;
}
int main(){

    cout << "Next string coming up in one second!" << endl;
    sleep(1.0);
    cout << "Hey, what did I miss?" << endl;

    return 0;
}

Syntax:

leerer Schlaf (vorzeichenlose Sekunden);

sleep () unterbricht die Ausführung für ein Intervall (Sekunden). Bei einem Ruhezustand wird das aktuelle Programm für die durch das Argument Sekunden angegebene Anzahl von Sekunden von der Ausführung angehalten. Das Intervall ist nur auf die nächste Hundertstelsekunde oder auf die Genauigkeit der Betriebssystemuhr genau, je nachdem, welcher Wert weniger genau ist.

Viele andere haben gute Informationen zum Schlafen geliefert. Ich stimme Wedge zu, dass ein Schlaf selten die am besten geeignete Lösung ist.

Wenn Sie schlafen, während Sie auf etwas warten, ist es besser, wenn Sie tatsächlich auf dieses Ding / Ereignis warten. Schauen Sie sich dazu die Bedingungsvariablen an.

Ich weiß nicht, auf welchem ​​Betriebssystem Sie dies versuchen, aber zum Threading und zur Synchronisierung können Sie sich die Boost-Threading- Bibliotheken ( Boost Condition Varriable ) ansehen .

Wenn Sie jetzt versuchen, auf außergewöhnlich kurze Zeiträume zu warten, gibt es einige Optionen für den Hack-Stil. Wenn Sie auf einer Art eingebetteter Plattform arbeiten, auf der kein "Schlaf" implementiert ist, können Sie eine einfache Schleife (für / während usw.) mit einem leeren Körper versuchen (achten Sie darauf, dass der Compiler sie nicht entfernt). Natürlich hängt die Wartezeit in diesem Fall von der jeweiligen Hardware ab. Für wirklich kurze Wartezeiten können Sie eine Assembly "nop" versuchen. Ich bezweifle sehr, dass dies das ist, wonach Sie suchen, aber ohne zu wissen, warum Sie warten müssen, ist es schwierig, genauer zu sein.

Unter Windows können Sie die Windows-Bibliothek einschließen und "Sleep (0);" das Programm zu schlafen. Es wird ein Wert angenommen, der Millisekunden darstellt.