web-dev-qa-db-fra.com

Dormez pendant des millisecondes

Je connais la fonction POSIX sleep(x) qui met le programme en veille pendant x secondes. Existe-t-il une fonction permettant de mettre le programme en veille pendant x millisecondes en C++?

c++linuxsleep
556
Prasanth Madhavan

Notez qu'il n'y a pas d'API C standard pour les millisecondes, vous devrez donc vous contenter de usleep, qui accepte les microsecondes:

#include <unistd.h>

unsigned int microseconds;
...
usleep(microseconds);
422
Niet the Dark Absol

En C++ 11, vous pouvez le faire avec des bibliothèques standard:

#include <chrono>
#include <thread>

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

Clair et lisible, plus besoin de deviner les unités prises par la fonction sleep().

1114
HighCommander4

Pour rester portable, vous pouvez utiliser Boost :: Thread pour dormir:

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

Cette réponse est un doublon et a été publiée dans cette question auparavant. Peut-être pourriez-vous aussi y trouver des réponses utiles.

79
MOnsDaR

Sous Unix, vous pouvez utiliser sleep .

Dans Windows, il y a veille .

31
INS

En fonction de votre plate-forme, vous pouvez avoir usleep ou nanosleep disponible. usleep est obsolète et a été supprimé du dernier standard POSIX; nanosleep est préférable.

30
CB Bailey

Pourquoi ne pas utiliser la bibliothèque time.h? Fonctionne sur les systèmes Windows et POSIX:

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

Code corrigé - la CPU reste à l'état IDLE [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;
}
18
Bart Grzybicki

nanosleep est un meilleur choix que usleep - il est plus résistant aux interruptions.

17
Johan Kotlinski
#include <windows.h>

Syntaxe:

Sleep (  __in DWORD dwMilliseconds   );

tilisation:

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

Si vous utilisez MS Visual C++ 10.0, vous pouvez le faire avec des facilités de bibliothèque standard:

Concurrency::wait(milliseconds);

tu auras besoin de:

#include <concrt.h>
7
Metronit

La méthode pour mettre votre programme en sommeil en C++ est la méthode Sleep(int). Le fichier d'en-tête correspondant est #include "windows.h."

Par exemple:

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

Le temps qu'il dort est mesuré en millisecondes et n'a pas de limite.

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

Sur les plates-formes dotées de la fonction select (POSIX, Linux et Windows), vous pouvez effectuer les opérations suivantes:

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

Cependant, il existe de meilleures alternatives disponibles de nos jours.

4
Maxim Egorushkin

Utilisez des threads d'entrée/sortie asynchrones Boost, veillez pendant x millisecondes;

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

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

Sélectionner un appel est un moyen d’avoir plus de précision (le temps de sommeil peut être spécifié en nanosecondes).

3
Madhava Gaikwad

La question est ancienne, mais j'ai réussi à trouver un moyen simple de l'inclure dans mon application. Vous pouvez créer une macro C/C++ comme indiqué ci-dessous, utilisez-la:

#ifndef MACROS_H
#define MACROS_H

#include <unistd.h>

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

#endif // MACROS_H
1
Vaibhav Pandey

En remplacement de Win32 pour les systèmes POSIX:

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

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