Comment obtenir la durée, int milli et float secondes de <chrono>?

Je suis en train d'utiliser le chrono de la bibliothèque pour les minuteries et les durées.

Je veux être en mesure d'avoir un Duration frameStart; ( à partir de l'app début )
et un Duration frameDelta; ( le temps entre les images )

J'ai besoin d'être en mesure d'obtenir la frameDelta la durée en millisecondes et en float secondes.

Comment faites-vous cela avec le nouveau c++11 <chrono> les bibliothèques? J'ai travaillé sur elle et googler ( l'information est rare ). Le code est fortement basé sur un modèle et nécessite des moulages et des choses, je ne peux pas comprendre comment utiliser cette bibliothèque correctement.

Affecter la durée d'une durée avec un ratio secondes (ou millisecondes) et ensuite appeler count sur elle...
auto delta = duration_cast<les secondes> (frameDelta).count(); Comme cela? Il renvoie un long long n'est pas un float.
si la durée a une résolution plus élevée que le type que vous attribuez ensuite, la mission sera mal formé, pour éviter de perdre de la précision. Vous avez besoin d'utiliser une durée d'une représentation à virgule flottante, ou de l'utilisation duration_cast
Oh, alors je l'utilise mal! 🙁

InformationsquelleAutor EddieV223 | 2013-01-18

c++c++11 chrono timer

129

Est-ce que vous cherchez?
```
#include <chrono>
#include <iostream>

int main()
{
    typedef std::chrono::high_resolution_clock Time;
    typedef std::chrono::milliseconds ms;
    typedef std::chrono::duration<float> fsec;
    auto t0 = Time::now();
    auto t1 = Time::now();
    fsec fs = t1 - t0;
    ms d = std::chrono::duration_cast<ms>(fs);
    std::cout << fs.count() << "s\n";
    std::cout << d.count() << "ms\n";
}
```
qui, pour moi, imprime:
```
6.5e-08s
0ms
```
- pourquoi ne pas utiliser auto sur fs et d?
- L'utilisation de auto serait bien pour d, comme le résultat de la duration_cast<ms> est ms. Cependant, pour fs auto ne serait pas approprié, parce que le résultat de t1-t0 a type high_resolution_clock::duration qui n'est pas nécessairement du même type que duration<float>. Par exemple, sur mon système, c'est duration<long long, nano>. Donc, il y a une conversion implicite de l'intégrale basée sur nanoseconds flotter à base de seconds qui se passe sur cette ligne, uniquement parce que le type de destination est spécifiée avec fsec.
- C'est de l'information utile. Juste par curiosité: serait - auto fs = std::chrono::duration_cast<fsec>(t1 - t0); être pédant overkill?
- Qui pourrait fonctionner tout aussi bien, et de faire exactement la même chose. Quant à ce qui devrait être préféré est entièrement stylistique autant que je suis concerné.
- sachez que, dans certains des scénarios du monde réel (le ms compilateur et les bibliothèques, par exemple) les 'high_resolution_clock' va manquer de temps de l'ordre de quelques microsecondes et ce code va cracher des zéros,
- Oui, dans ce cas, vous pourriez envisager de rouler votre propre horloge comme démontré ici: stackoverflow.com/a/5524138/576911
- Rouler votre propre horloge est probablement excessif. Si vous venez d'utiliser la steady_clock au lieu de cela, ce qui élimine la question de l'horloge est réglée pendant que vous l'utilisez, et même sur Windows le steady_clock a une résolution de nanosecondes, ce qui est suffisant pour la plupart des applications.
- Comment pourrais-je définir un float-durée dans une unité autre que des secondes? Il semble se convertir à d'autres unités de temps à l'aide de duration_cast retourne toujours des nombres entiers...
- Le type de retour de duration_cast<D> est D, si D est une partie intégrante de base ou à virgule flottante fonction. Exemple de flotter à base de millisecondes: youtube.com/watch?v=P32hvk8b13M&t=28m49s
InformationsquelleAutor Howard Hinnant
14

Je ne sais pas ce que "millisecondes et float secondes, mais ce devrait vous donner une idée:
```
#include <chrono>
#include <thread>
#include <iostream>

int main()
{
  auto then = std::chrono::system_clock::now();
  std::this_thread::sleep_for(std::chrono::seconds(1));
  auto now = std::chrono::system_clock::now();
  auto dur = now - then;
  typedef std::chrono::duration<float> float_seconds;
  auto secs = std::chrono::duration_cast<float_seconds>(dur);
  std::cout << secs.count() << '\n';
}
```
- Je suppose qu'il veut le réel count comme un float?
- C'est ce qui sera imprimé à la fin. Mais je ne sais pas si il veut millisecondes comme un entier, ou en millisecondes-delà de la seconde, ou quoi.
- J'aimerais être en mesure d'obtenir à partir d'un chrono::durée la durée représenté comme un int millisecondes, ou flotter secondes(fraction de seconde)
- Howard réponse c'est exactement ce que
InformationsquelleAutor Jonathan Wakely
11

De prendre une deviner ce que c'est que vous demandez. Je suis en supposant que par ordre de la milliseconde cadre de la minuterie vous êtes à la recherche de quelque chose qui agit comme la suivante,
```
double mticks()
{
    struct timeval tv;
    gettimeofday(&tv, 0);
    return (double) tv.tv_usec / 1000 + tv.tv_sec * 1000;
}
```
mais utilise std::chrono au lieu de cela,
```
double mticks()
{
    typedef std::chrono::high_resolution_clock clock;
    typedef std::chrono::duration<float, std::milli> duration;

    static clock::time_point start = clock::now();
    duration elapsed = clock::now() - start;
    return elapsed.count();
}
```
Espère que cette aide.
- Bienvenue à Débordement de Pile. Il serait génial si vous pouviez fournir des détails supplémentaires à votre code. Il serait d'aider d'autres personnes à comprendre ce que vous essayez d'accomplir et la façon dont vos solutions fonctionne. Merci!
InformationsquelleAutor Billy The Kid

Dans AAA style à l'aide de la explicitement tapé initialiseur de l'idiome:

#include <chrono>
#include <iostream>

int main(){
  auto start = std::chrono::high_resolution_clock::now();
  //Code to time here...
  auto end = std::chrono::high_resolution_clock::now();

  auto dur = end - start;
  auto i_millis = std::chrono::duration_cast<std::chrono::milliseconds>(dur);
  auto f_secs = std::chrono::duration_cast<std::chrono::duration<float>>(dur);
  std::cout << i_millis.count() << '\n';
  std::cout << f_secs.count() << '\n';
}

InformationsquelleAutor Chris Drew

Vous devez vous connecter pour publier un commentaire.