Schlaf für Millisekunden

In C++ 11 können Sie dies mit Standardbibliotheksfunktionen tun:

#include <chrono>
#include <thread>

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

Klar und lesbar, Sie müssen nicht mehr raten, in welchen Einheiten die Funktion sleep() ausgeführt wird.

Um mobil zu bleiben, können Sie Boost :: Thread zum Schlafen verwenden:

#include <boost/thread/thread.hpp>

int main()
{
    //waits 2 seconds
    boost::this_thread::sleep( boost::posix_time::seconds(1) );
    boost::this_thread::sleep( boost::posix_time::milliseconds(1000) );

    return 0;
}

Diese Antwort ist ein Duplikat und wurde bereits in diese Frage veröffentlicht. Vielleicht finden Sie dort auch brauchbare Antworten.

In Unix können Sie sleep verwenden.

In Windows gibt es Sleep .

Abhängig von Ihrer Plattform sind möglicherweise usleep oder nanosleep verfügbar. usleep ist veraltet und wurde aus dem neuesten POSIX-Standard gelöscht. nanosleep wird bevorzugt.

Warum nicht die Bibliothek time.h benutzen? Läuft auf Windows- und POSIX-Systemen:

#include <iostream>
#include <time.h>

using namespace std;

void sleepcp(int milliseconds);

void sleepcp(int milliseconds) // Cross-platform sleep function
{
    clock_t time_end;
    time_end = clock() + milliseconds * CLOCKS_PER_SEC/1000;
    while (clock() < time_end)
    {
    }
}
int main()
{
    cout << "Hi! At the count to 3, I'll die! :)" << endl;
    sleepcp(3000);
    cout << "urrrrggghhhh!" << endl;
}

Korrigierter Code - CPU bleibt jetzt im IDLE-Status [2014.05.24]:

#include <iostream>
#ifdef _WIN32
    #include <windows.h>
#else
    #include <unistd.h>
#endif // _WIN32

using namespace std;

void sleepcp(int milliseconds);

void sleepcp(int milliseconds) // Cross-platform sleep function
{
    #ifdef _WIN32
        Sleep(milliseconds);
    #else
        usleep(milliseconds * 1000);
    #endif // _WIN32
}
int main()
{
    cout << "Hi! At the count to 3, I'll die! :)" << endl;
    sleepcp(3000);
    cout << "urrrrggghhhh!" << endl;
}

nanosleep ist eine bessere Wahl als usleep - es ist widerstandsfähiger gegen Interrupts.

#include <windows.h>

Syntax:

Sleep (  __in DWORD dwMilliseconds   );

Verwendung:

Sleep (1000); //Sleeps for 1000 ms or 1 sec

Wenn Sie MS Visual C++ 10.0 verwenden, können Sie dies mit Standardbibliotheksfunktionen tun:

Concurrency::wait(milliseconds);

du wirst brauchen:

#include <concrt.h>

Die Methode, mit der Sie Ihr Programm in C++ in den Ruhezustand versetzen können, ist Sleep(int). Die Header-Datei dafür ist #include "windows.h."

Zum Beispiel:

#include "stdafx.h"
#include "windows.h"
#include "iostream"
using namespace std;

int main()
{
    int x = 6000;
    Sleep(x);
    cout << "6 seconds have passed" << endl;
    return 0;
}

Die Ruhezeit wird in Millisekunden gemessen und ist unbegrenzt.

Second = 1000 milliseconds
Minute = 60000 milliseconds
Hour = 3600000 milliseconds

Auf Plattformen mit der Funktion select (POSIX, Linux und Windows) können Sie Folgendes ausführen:

void sleep(unsigned long msec) {
    timeval delay = {msec / 1000, msec % 1000 * 1000};
    int rc = ::select(0, NULL, NULL, NULL, &delay);
    if(-1 == rc) {
        // Handle signals by continuing to sleep or return immediately.
    }
}

Heutzutage gibt es jedoch bessere Alternativen.

Verwenden Sie Boost für asynchrone Eingabe-/Ausgabethreads und schlafen Sie für x Millisekunden.

#include <boost/thread.hpp>
#include <boost/asio.hpp>

boost::thread::sleep(boost::get_system_time() + boost::posix_time::millisec(1000));

Select Call bietet eine präzisere Möglichkeit (die Ruhezeit kann in Nanosekunden angegeben werden).

Die Frage ist alt, aber ich habe es geschafft, einen einfachen Weg zu finden, dies in meiner App zu haben. Sie können ein C/C++ - Makro wie unten gezeigt erstellen und verwenden:

#ifndef MACROS_H
#define MACROS_H

#include <unistd.h>

#define msleep(X) usleep(X * 1000)

#endif // MACROS_H

Als Win32-Ersatz für POSIX-Systeme:

void Sleep(unsigned int milliseconds) {
    usleep(milliseconds * 1000);
}

while (1) {
    printf(".");
    Sleep((unsigned int)(1000.0f/20.0f)); // 20 fps
}