std::chrono et cout

J'ai un problème stupide. J'essaie de passer au c++11 en-têtes et un de ceux qui est du chrono. Mais mon problème est que je ne peux pas cout le résultat des opérations en temps. Par exemple:

auto t=std::chrono::high_resolution_clock::now();
cout<<t.time_since_epoch();

donne:

l'initialisation de l'argument 1 de ‘std::basic_ostream<_CharT, _Traits>& std::operator<<(std::basic_ostream<_CharT, _Traits>&&, const _Tp&) [with _CharT = char, _Traits = std::char_traits<char>, _Tp = std::chrono::duration<long int, std::ratio<1l, 1000000l> >]’ ... /usr/include/c++/4.6/ostream

cout<<(uint64_t)t.time_since_epoch();

donne invalide cast

InformationsquelleAutor NoSenseEtAl | 2011-10-25

c++c++11 chrono time

22

Une rapide recherche sur google trouvé cette page: http://en.cppreference.com/w/cpp/chrono/duration, où vous pouvez trouver un exemple de l'impression de la une durée.

Edit: il s'est déplacé à http://en.cppreference.com/w/cpp/chrono/duration/duration_cast
- j'utilise ce wiki, mais je n'ai jamais trouvé... tnx
- Méfiez-vous que le lié exemple est différente en ce qu'elle imprime la différence entre les deux invocations de maintenant(), et n'implique pas de time_since_epoch(). En fait, time_since_epoch laisse le époque indéterminée (cela dépend de l'horloge à partir de laquelle vous avez obtenu le time_point). Donc, en bref, la durée de l'impression est une sorte de sens sans les accompagner d'informations sur l'époque.
InformationsquelleAutor Some programmer dude
34

Comme d'autres l'ont noté, vous pouvez appeler le count() fonction membre pour obtenir le décompte interne.

Je voulais ajouter que je cherche à ajouter un nouvel en-tête: <chrono_io> à cette bibliothèque. Il est documenté ici. Le principal avantage de <chrono_io> plus simplement à l'aide de count() est que la compilation des unités de temps sont imprimés pour vous. Cette information est bien sûr à obtenir manuellement, mais il est beaucoup plus facile d'avoir de la bibliothèque pour vous.

Pour moi, votre exemple:
```
#include <iostream>
#include <chrono_io>

int main()
{
    auto t = std::chrono::high_resolution_clock::now();
    std::cout << t.time_since_epoch() << '\n';
}
```
Sorties:
```
147901305796958 nanoseconds
```
Le code source pour ce faire est open source et disponible sur le lien ci-dessus. Il se compose de deux en-têtes: <ratio_io> et <chrono_io>, et 1 source: chrono_io.cpp.

Ce code doit être considérée comme expérimentale. Il n'est pas standard, et presque certainement ne sera pas normalisée est. En effet observations préliminaires formulées par confiées au groupe de travail indiquent qu'ils préfèrent la sortie par défaut pour être ce que ce logiciel appelle la "forme courte". Cette alternative de sortie peut être obtenu auprès de:
```
std::cout << std::chrono::duration_fmt(std::chrono::symbol)
          << t.time_since_epoch() << '\n';
```
Et sorties:
```
147901305796958 ns
```
- Par ma question initiale, vous pouvez deviner que je ne suis pas du rpc guru :), mais pourquoi ne pas vous surcharger time_since_epoch t.time_since_epoch(chrono::print_unit)
- En ce moment il y a très peu de chrono gourous de la planète. Donc, vous êtes bien! 🙂 J'ai peut-être mal compris votre suggestion, mais il semble que vous êtes suggérant pour définir les unités de la durée, au moins à des fins d'impression. Cela pourrait provoquer des imprécisions de conversions en silence prendre place, ce qui la conception de chrono est allé à la peine de prévenir. I. e. durée différente types ne convertir implicitement si il n'y a pas d'erreur de troncation faite par la conversion.
- ce que je voulais dire, c'est que vous surcharge de la fonction et de la surcharge retourne std::string qui a unité collé à la fin. ou vous pourriez avoir différents paramètres au lieu de print_unit ont print_nano, print_milli ou même print_unit<chrono::millisecondes>... ou tout simplement pour mettre à jour (w)le cout de prendre (avec << ) print_units...(aka std::cout<<chrono::print_units<<t.time_ ...) de mon point est que l'en-tête de la solution juste pour avoir l'impression de faire correctement semble désordonné. Et de donner des munitions à ceux qui haïssent... "vous souhaitez imprimer à l'unité de temps? Il y a un en-tête pour ça, d'ailleurs il ne sera pas normalisée pour 5 ans." 🙂
- Je vois, merci. Il est de tradition en C++ pour imprimer des choses en utilisant stream << object (c'était la première chose que vous avez essayé). Et il est préférable de s'en tenir à la tradition afin de ne pas confondre tout le monde (sauf si vous souhaitez concevoir un tout nouveau système d'e/S). Comme pour l'en-tête distincte, j'ai peut être parlé en mettant toutes les fonctionnalités de <chrono>. C'est un génie compromis (augmente le temps de compilation pour de nombreux cas d'utilisation). La normalisation calendrier: Nous sommes très chanceux de voir <chrono> en C++11. Nous avons presque réussi à C12 est xtime à la place. La normalisation est beaucoup plus difficile que de conception.
- Je comprends, parfois(comme quand j'ai lu que l'origine de la STL a dû être réduite pour des raisons politiques , ou quand je vois les membres de la commission de donner des conférences à Google et en disant que vous connaissez peut vous épargner quelques centaines de k USD ) je souhaite que Bjorne s'arrête à la norme ISO choses et faire des choses avec l'aide de MS, Google,... 🙂
- toutes les nouvelles concernant cet en-tête? Je n'ai pas entendu quelque chose à ce sujet récemment au sujet de la normalisation
- Désolé, pas de nouvelles. Si suffisamment de gens font assez de bruit sur une question donnée, il arrive, sinon ça ne marche pas.
- Triste de voir que la recherche de propositions sur le chrono i/o de ne pas apporter quoi que ce soit, sauf pour cette réponse. Nous aurions vraiment besoin d'un tel ajout. Aussi fixe vos liens car ils sont cassés.
- Merci.
- Le projet de proposition, y compris la mise en forme pour les durées: howardhinnant.github.io/date/d0355r1.html
- Progression: wg21.lien/p0355
- L'impression des durées est maintenant dans le C++20 projet de spec, bien que la syntaxe exacte et un format différents de ceux présentés dans ma réponse.
InformationsquelleAutor Howard Hinnant

Si vous voulez timing dans la résolution de millisecondes, c'est comment vous pouvez le faire:

auto t1 = std::chrono::high_resolution_clock::now();
//process to be timed
auto t2 = std::chrono::high_resolution_clock::now();
std::cout << "process took: "
    << std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1).count()
    << " milliseconds\n";

N'oubliez pas d'ajouter parmi les en-têtes inclus:

#include <chrono> //timing

InformationsquelleAutor Yonatan Simson

7

Pas sûr de ce que vous attendez de ce casting, peut-être que vous avez voulu t.time_since_epoch().count()?

InformationsquelleAutor Michael Krelin - hacker

Vous devez vous connecter pour publier un commentaire.