web-dev-qa-db-fra.com

Comment ajouter un délai à un programme C ++?

J'essaie d'ajouter un délai dans un programme C++ et je me demandais si quelqu'un avait des suggestions sur ce que je pouvais essayer ou des informations à examiner.

J'aimerais avoir plus de détails sur la manière dont j'applique ce délai, mais tant que je n'aurai pas plus d'informations sur la façon d'ajouter un délai, je ne suis pas sûr de la manière dont je devrais même essayer de le mettre en œuvre.

c++time
67
Matt Pascoe

Win32: Sleep(milliseconds) est ce que vous êtes

unix: usleep(microseconds) est ce que vous voulez.

sleep () ne prend que quelques secondes, ce qui est souvent trop long.

65
Richard Harrison

Une réponse mise à jour pour C++ 11:

Utilisez le sleep_for et sleep_until les fonctions:

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

Avec ces fonctions, il n'est plus nécessaire d'ajouter continuellement de nouvelles fonctions pour une meilleure résolution: sleep, usleep, nanosleep, etc. sleep_for et sleep_until sont des fonctions modèles qui peuvent accepter les valeurs de toutes résolutions via chrono types; heures, secondes, femtosecondes, etc.

En C++ 14, vous pouvez simplifier davantage le code avec les suffixes littéraux pour nanoseconds et 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);
}

Notez que la durée réelle d'un sommeil dépend de l'implémentation: vous pouvez demander à dormir pendant 10 nanosecondes, mais une implémentation peut finir par dormir pendant une milliseconde à la place, si elle est la plus courte possible.

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

Cela dormira également pendant trois secondes. Vous pouvez cependant affiner les chiffres un peu plus.

27
Samir Talwar

Voulez-vous quelque chose d'aussi simple que

sleep(3);
10
J.J.

Notez que cela ne garantit pas que le temps de sommeil du thread sera à peu près proche de la période de sommeil, mais seulement que le temps nécessaire avant que le thread continue son exécution sera au moins égal à la quantité souhaitée. Le délai réel varie en fonction des circonstances (en particulier de la charge sur la machine en question) et peut être de plusieurs ordres de grandeur plus élevé que le temps de sommeil souhaité.

En outre, vous n'indiquez pas pourquoi vous devez dormir mais vous devez généralement éviter d'utiliser les retards comme méthode de synchronisation.

8
Wedge

J'ai trouvé que "_sleep(milliseconds);" (sans les guillemets) fonctionne bien pour Win32 si vous incluez la bibliothèque chrono

Par exemple:

#include <chrono>

using namespace std;

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

Assurez-vous d'inclure le trait de soulignement avant de dormir.

3
ARoberts

Vous pouvez également utiliser select (2) si vous voulez une précision en microsecondes (cela fonctionne sur une plate-forme qui n'a pas usleep (3))

Le code suivant attendra 1,5 seconde:

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

`

3
Mathias Brossard

Oui, le sommeil est probablement la fonction de choix ici. Notez que le temps passé dans la fonction est la plus petite durée d'inactivité du thread appelant. Ainsi, par exemple, si vous appelez sleep avec 5 secondes, votre fil de discussion sera en veille pendant au moins 5 secondes. Pourrait être 6, ou 8 ou 50, en fonction de ce que fait le système d'exploitation. (Pendant l'exécution optimale du système d'exploitation, ce sera très proche de 5).
Une autre fonctionnalité utile de la fonction de veille est de passer en 0. Cela forcera le changement de contexte de votre thread.

Quelques informations supplémentaires:
http://www.opengroup.org/onlinepubs/000095399/functions/sleep.html

2
Marcin

pour retarder la sortie dans cpp pour une durée fixe, vous pouvez utiliser la fonction Sleep () en incluant la syntaxe de fichier d'en-tête Windows.h pour la fonction Sleep () en veille (time_in_ms)

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

SORTIE. Le code ci-dessus sera imprimé Apple) et attendez 3 secondes avant d’imprimer Mango.

1
Abhishek Rathore

Vous pouvez essayer cet extrait de code:

#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));
}
1
Jayesh Rathod

Syntaxe:

vide sommeil (secondes non signées);

sleep () suspend l'exécution pendant un intervalle (secondes). Avec un appel en veille, l'exécution du programme en cours est suspendue pendant le nombre de secondes spécifié par l'argument secondes. L’intervalle n’est précis qu’au centième de seconde près ou à la précision de l’horloge du système d’exploitation, selon ce qui est le moins précis.

0
GEOCHET

Beaucoup d'autres ont fourni de bonnes informations pour dormir. Je conviens avec Wedge qu'un sommeil est rarement la solution la plus appropriée.

Si vous dormez pendant que vous attendez quelque chose, vous feriez mieux d’attendre réellement cette chose/cet événement. Examinez les variables de condition pour cela.

Je ne sais pas sur quel système d'exploitation vous essayez de faire cela, mais pour le threading et la synchronisation, vous pouvez vous tourner vers les bibliothèques Boost Threading ( Boost Condition Varriable ).

Si vous essayez d’attendre des périodes exceptionnellement courtes, il existe deux options de style de hack. Si vous travaillez sur une sorte de plate-forme intégrée dans laquelle un "sommeil" n'est pas implémenté, vous pouvez essayer une simple boucle (pour/tant que tout le reste) avec un corps vide (attention, le compilateur ne l'optimise pas à l'extérieur). Bien entendu, le temps d'attente dépend du matériel spécifique dans ce cas. Pour des "attentes" vraiment courtes, vous pouvez essayer une Assemblée "nop". Je doute fort que ce soit ce que vous recherchez, mais sans savoir pourquoi vous devez attendre, il est difficile d'être plus précis.

0
Michael

Sous Windows, vous pouvez inclure la bibliothèque Windows et utiliser "Sleep (0);" dormir le programme. Il prend une valeur qui représente des millisecondes.

0
Zee JollyRoger