clock() est-il fiable pour une minuterie?

Question

J'utilise clock(), et je me demande si elle se réinitialise ou atteint un maximum. Tout ce que je suis en train de l'utiliser est juste trop le soumettre d'un appel de fonction précédente et trouver la différence.

Merci pour l'aide jusqu'à présent, mais je ne suis pas vraiment en mesure d'obtenir le chrono fonctionne dans VS '12 mais c'est bien parce que je pense que c'est un peu plus que nécessaire, je pensais utiliser le temps() mais je n'ai aucune idée de la façon de convertir le t_time en un int qui contient seulement les secondes actuelles 0-60, de l'aide?

Answer 1

En ce qui concerne la norme concerne,

La portée et la précision des temps représentables dans clock_t et time_t sont définis par l'implémentation.

(C99, §7.23.1 ¶4)

donc il n'y a aucune garantie de gamme; la définition de clock() ne dit rien au sujet enroulant autour, mais il dit que

Si le temps processeur utilisé est pas disponible ou sa valeur ne peut pas être représentée, la fonction retourne la valeur (clock_t)(-1)

Alors on peut dire que le dépassement de la plage de clock_t peut être vu comme "sa valeur ne peut être représentée"; d'autre part, cette interprétation signifierait qu'après un certain temps, clock() deviendrait complètement inutile.

Dans les faits, si nous nous attelons à une mise en œuvre spécifique (glibc), nous voyons:

matteo@teokubuntu:~$ man 3 clock 

Note that the time can wrap around. On a 32-bit system where 
    CLOCKS_PER_SEC equals 1000000 this function will return the same value 
    approximately every 72 minutes. 

Answer 2

dépend de ce système que vous êtes. Il peut utiliser un 32+ ou un 64 bits clock_t. Il va certainement se renverser, mais s'il est en 64 bits, il sera OK pendant un certain temps avant qu'il ne se renverse - 2 microsecondes est encore un temps terrible (environ 2 secondes, et il y a environ 2 secondes par jour, donc 2 jours - ce qui est d'environ 2 , ou un million, années ...;)

Bien sûr, dans un système 32 bits, nous avons environ 2 = 4096 secondes à une résolution de microseconde. Une heure étant 3600s = environ 1h10m.

Cependant, un autre problème, dans certains systèmes, est que clock() renvoie le temps CPU utilisé, donc si vous dormez, il ne compte pas comme temps dans clock(). Et bien sûr, même si CLOCKS_PER_SEC peut être 1000000, cela ne signifie pas que vous obtenez une résolution de microsecondes - dans de nombreux systèmes, il "saute" 10000 unités à la fois.

En résumé, "probablement une mauvaise idée".

Si vous avez C++ 11 sur le système, utilisez std::chrono, qui a plusieurs options pour Chronométrage qui sont suffisamment bonnes pour la plupart des buts (mais font étudier la std::chrono docs)

Exemple Code:

#include <iostream> 
#include <chrono> 
#include <unistd.h> // replace with "windows.h" if needed. 

int main() 
{ 
    std::chrono::time_point<std::chrono::system_clock> start, end; 

    start = std::chrono::system_clock::now(); 
// 10 seconds on a unix system. Sleep(10000) on windows will be the same thing 
    sleep(10); 
    end = std::chrono::system_clock::now(); 

    int elapsed_seconds = std::chrono::duration_cast<std::chrono::seconds> 
          (end-start).count(); 
    std::cout << "elapsed time: " << elapsed_seconds << "s\n"; 
} 

Answer 3

La réponse simple est que si vous l'utilisez simplement pour chronométrer une fonction, elle ne fonctionnera probablement pas. Cela peut aussi être trop lent et vous risquez de voir une durée de fonction de zéro. Si vous voulez un timing précis pour une fonction qui s'exécute rapidement, il vaut probablement mieux utiliser un appel au niveau OS comme this one on Windows.