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

Question

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 à consulter?

J'aimerais avoir plus de détails sur la manière dont je mets en œuvre ce délai, mais tant que je n'aurai pas plus d'informations sur la manière 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.

Answer 1

Win32: Veille (millisecondes) , c'est ce que vous êtes

unix: usleep (microsecondes) est ce que vous veux.

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

Answer 2

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

Utilisez les fonctions sleep_for et sleep_until :

#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. < code> sleep_for et sleep_until sont des fonctions modèles qui peuvent accepter les valeurs de toute résolution via les types chrono ; heures, secondes, femtosecondes, etc.

En C ++ 14, vous pouvez simplifier davantage le code avec les suffixes littéraux pour nanosecondes et secondes :

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

Answer 3

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

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

Answer 4

Voulez-vous quelque chose d'aussi simple que

sleep(3);

Answer 5

Notez que cela ne garantit pas que le temps de sommeil du thread sera 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 de la machine en question) et peut être de plusieurs ordres de grandeur plus élevé que le temps de veille souhaité.

En outre, vous ne répertoriez pas les raisons pour lesquelles vous devez dormir, mais vous devez généralement éviter d'utiliser des retards comme méthode de synchronisation.

Answer 6

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

`

Answer 7

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

.

E.g:

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

Answer 8

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 en mode veille avec 5 secondes, votre fil 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

Answer 9

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

Answer 10

pour retarder la sortie dans cpp pour une durée fixe, vous pouvez utiliser la fonction Sleep () en incluant le fichier d’en-tête windows.h La syntaxe de la fonction Sleep () est Sleep (time_in_ms) comme

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

SORTIE. Le code ci-dessus imprimera Apple et attendra 3 secondes avant d’imprimer Mango.

Answer 11

Syntaxe:

annuler la veille (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.

Answer 12

De nombreux autres ont fourni de bonnes informations pour dormir. Je suis d’accord avec Wedge pour dire que dormir constitue 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 vous pouvez vous reporter à Boost Threading ( La condition de suralimentation peut être modifiée ).

Passons maintenant à l’extrême extrême si vous essayez d’attendre pendant des périodes exceptionnellement courtes, puis il existe plusieurs 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" très courtes, vous pouvez essayer un assemblage "nop". Je doute fort que ce soit ce que vous cherchez, mais sans savoir pourquoi vous devez attendre, il est difficile d'être plus précis.

Answer 13

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.