Les timer en c++

Version imprimable

28/04/2014, 15h47
DavidleVrai

Les timer en c++

Bonjour,

J'ai une question de débutant de la première heure sur les timer en c++. Comment ça marche ?

Excusez moi de poser cette question mais je n'ai rien trouvé sur la FAQ de développez et j'ai l'impression que sur le net je suis tombé sur des exemples venant du C. J'aimerai utiliser quelque chose de propre.

Je veux faire juste qu'un morceau de code s'exécute pendant xsecondes.

Merci d'avance pour votre aide.

Hello,

De manière générale le fonctionnement est le suivant

Code:

1
2
3
Tant qu'il reste du temps
    faire quelque chose
Fin tant que

Ça peut se faire très simplement

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <chrono>
#include <iostream>
 
int main() {
	// afiche "Hi !" en boucle pendant 5 seondes
	// on initialise l'heure de fin à l'heure courante + 5 secondes
	// puis on compare l'heure courante à l'heure de fin à chaque itération
	// on sort de la boucle quand l'heure de fin est dépassée
	for(auto runUntil = std::chrono::system_clock::now() + std::chrono::seconds(5);
		std::chrono::system_clock::now() < runUntil;)
	{
		// Do something
		std::cout << "Hi !" << std::endl;
	}
	return 0;
}

Certaines libs permettent de simplifier ça, ou de rendre le code plus expressif (deadline_timer de boost::asio par exemple).
Exemple avec un deadline_timer.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <boost/asio.hpp>
#include <iostream>
#include <atomic>
 
int main() {
	std::atomic<bool> shouldStop = false;
	boost::asio::io_service ios;
	boost::asio::deadline_timer timer(ios);
 
	// expires dans 5 sec
	timer.expires_from_now(boost::posix_time::seconds(5));
 
	// lambda exécutée quand le timer expire (on met shouldStop à true quand il expire)
	timer.async_wait([&shouldStop](const boost::system::error_code& error) {
		if(!error) {
			shouldStop = true;
		}	
	});
 
	// on effectue le traitement, en attendant que le timer expire
	while(!shouldStop) {
		// Do something
		std::cout << "Hi !" << std::endl;
	}
	return 0;
}

(Codes non testés)

29/04/2014, 09h48
DavidleVrai

Merci, c'est une réponse très claire.
30/04/2014, 20h59
Bishop01

Bonjour,
Je suis sure ce poste car les timers m'interressent... C'est la premiere fois que je vois une réponse aussi clair (bien que j'ai du mal à comprendre certaines lignes du deuxième code donnée comme les 3 premieres...).

En faite m'a question était avec les timers ... ;) Comment faire un décompte ? ;)

De la façon suivante: on demande à l'utilisateur combien de temps :

S'ilrentre 5 secondes alors : cela affiche : 5 + Le nombre de millisecondes
4 + Le nombre de millisecondes
3 + Le nombre de millisecondes
2 + Le nombre de millisecondes
1 + Le nombre de millisecondes
nombre de millisecondes restantes
fin du programme.
Cela est-il possible. Merci de m'aider. Et merci d'avance pour les réponses.
30/04/2014, 22h03
foetus
L'approche naïve avec les timers est la suivante:
On crée un timer, c'est à dire une action qui va se déclencher toutes les X [milli]secondes.

Pour ton compteur tu as une variable V qui contient le décompte.
Donc on peut juste faire une décrémentation de V: V--

Mais les problèmes sont les suivants: :mrgreen:
1. Le déclenchement n'est pas une science exacte. Si tu dis qu'il se déclenche toutes les secondes, un coup cela peut-être à 0.9s un autre à 1.1s, voire pire. Cela dépend de la charge de ton ordinateur
2. Ton action peut prendre plus de temps que prévu. Imagine que tu veux un timer toutes les secondes, mais que ton action prenne 1.1 seconde. Cela va être le bronx :mouarf:
Pour résoudre ces problèmes, à chaque déclenchement , on va prendre le temps écoulé depuis le dernier, et faire un calcul avec le temps (linéaire bête et méchant)

Disons que tu veux un décompte toutes les X [milli]secondes:
Calcul du nouveau décrément Y
X -> 1
(current_t - last_t) -> Y

nouveau décrément Y = (current_t - last_t) / X :mrgreen: (si je ne me suis pas trompé)
30/04/2014, 23h14
Iradrille

Citation:

Envoyé par Bishop01

bien que j'ai du mal à comprendre certaines lignes du deuxième code donnée comme les 3 premieres...

Ce sont simplement des déclarations de variables, je te renvoi vers la doc de deadline_timer, et de std::atomic pour voir leur utilités.

Ce que tu cherches à faire est au final très proche du premier code que j'ai donné : on calcule le temps restant pour savoir si on doit sortir de la boucle ou pas.
Tu as juste à afficher le temps restant dans la boucle pour avoir un décompte.