Problema al progtwigr tareas utilizando la función clock ()

Me gustaría progtwigr tareas en diferentes intervalos de tiempo: a 0.1 seg, 0.9s …. 2s etc. Uso la función clock () C ++ que devuelve el número de tics desde el comienzo de la simulación y convierto el número de ticks a segundos usando CLOCKS_PER_SEC pero he notado que la tarea no está progtwigda cuando el instante es flotante, pero cuando es un número entero, sí lo es. Aquí la parte del código responsable de la progtwigción:

float goal = (float) clock() / CLOCKS_PER_SEC + 0.4 ; // initially (float) clock() / CLOCKS_PER_SEC = 0 ; if ((float) clock() / CLOCKS_PER_SEC == goal) do stuff ; 

En ese caso, no funciona, pero cuando programo la tarea en 3 segundos, por ejemplo, funciona. ¿Es un problema de precisión?

Si tuviera que implementar algún mecanismo de temporizador en C ++, probablemente usaría el std::chrono nombres std::chrono junto con std::priority_queue .

 #include  #include  #include  #include  // for `time_t` and `struct timeval` namespace events { struct event { typedef std::function callback_type; typedef std::chrono::time_point time_type; event(const callback_type &cb, const time_type &when) : callback_(cb), when_(when) { } void operator()() const { callback_(); } callback_type callback_; time_type when_; }; struct event_less : public std::less { bool operator()(const event &e1, const event &e2) const { return (e2.when_ < e1.when_); } }; std::priority_queue, event_less> event_queue; void add(const event::callback_type &cb, const time_t &when) { auto real_when = std::chrono::system_clock::from_time_t(when); event_queue.emplace(cb, real_when); } void add(const event::callback_type &cb, const timeval &when) { auto real_when = std::chrono::system_clock::from_time_t(when.tv_sec) + std::chrono::microseconds(when.tv_usec); event_queue.emplace(cb, real_when); } void add(const event::callback_type &cb, const std::chrono::time_point &when) { event_queue.emplace(cb, when); } void timer() { event::time_type now = std::chrono::system_clock::now(); while (!event_queue.empty() && (event_queue.top().when_ < now)) { event_queue.top()(); event_queue.pop(); } } } 

Para usar, simplemente agregue eventos usando events::add , y llame a events::timer algunas veces por segundo.

Ejemplo:

 void foo() { std::cout << "hello from foo\n"; } void done() { std::cout << "Done!\n"; } struct bar { void hello() { std::cout << "Hello from bar::hello\n"; } }; auto now = std::chrono::system_clock::now(); bar b; events::add(foo, now + std::chrono::seconds(2)); events::add(std::bind(&bar::hello, b), now + std::chrono::seconds(4)); events::add(done, now + std::chrono::seconds(6)); while (true) { usleep(10000); events::timer(); } 

El ejemplo anterior se imprimirá:

 hola de foo
 hola de la barra :: hola
 ¡Hecho!

Una línea se imprimirá cada dos segundos. Después de "Done!" el progtwig simplemente repetirá siempre, sin hacer nada.

Tenga en cuenta que este progtwig contiene muchas funcionalidades de C ++ 11, pero se ha probado con GCC 4.4.5 y 4.7.1. VC ++ 2010 desafortunadamente no tiene el encabezado , pero el VC ++ 2012RC aparentemente lo tiene.

CLOCKS_PER_SEC es un número entero en su sistema. en otros sistemas, podría flotar también. poner (flotar) cerca de él también

El problema podría ser debido a su comparación de coma flotante. Esto puede proporcionar resultados inesperados. Por favor evita esto

Referir este enlace