Comment imprimez-vous un point C ++ 11?

(Dans cet article, je vais omettre std::chrono:: qualifications pour plus de clarté. J’espère que vous savez où ils vont.)

La raison pour laquelle votre exemple de code ne parvient pas à comstackr est qu’il existe une incompatibilité entre le type de retour de system_clock::now() et le type de variable time_point vous essayez d’affecter ( time_point ).

La valeur de retour documentée de system_clock::now() est system_clock::time_point , qui est un typedef pour time_point . system_clock::duration est défini par l’implémentation, les microseconds et les nanoseconds étant couramment utilisées. Il semble que votre implémentation utilise des microseconds , donc le type de retour de system_clock::now() est time_point .

time_point s avec des durées différentes ne sont pas implicitement convertibles les unes aux autres, vous obtenez donc une erreur de compilation.

Vous pouvez convertir explicitement des points de temps avec différentes durées à l’aide de time_point_cast , afin de comstackr les éléments suivants sur votre système:

 time_point time_point; time_point = time_point_cast(system_clock::now()); 

Notez que le paramètre de modèle explicite de time_point_cast correspond au type de durée cible et non au type time_point cible. Les types d’horloge doivent correspondre dans un time_point_cast . Il time_point_cast donc time_point_cast spécifier le type entier time_point (qui est basé sur le type d’horloge et le type de durée).

Bien sûr, dans votre cas, puisque vous ne faites qu’imprimer le point temporel, il n’est pas nécessaire qu’il ait une résolution spécifique, vous pouvez donc simplement déclarer que time_point est du même type que ce que system_clock::now() renvoie. pour commencer. Un moyen simple de le faire est d’utiliser le typedef system_clock::time_point :

 system_clock::time_point time_point; time_point = system_clock::now(); // no time_point_cast needed 

Comme il s’agit de C ++ 11, vous pouvez également utiliser auto :

 auto time_point = system_clock::now(); 

Ayant résolu cette erreur de compilation, la conversion en time_t fonctionne time_t :

 std::time_t now_c = std::chrono::system_clock::to_time_t(time_point); 

et vous pouvez maintenant utiliser des méthodes standard pour afficher les valeurs time_t , telles que std::ctime ou std::strftime . (Comme le souligne Cassio Neri dans un commentaire à votre question, la fonction C ++ – y std::put_time n’est pas encore supscope par GCC).

Cet extrait pourrait vous aider:

 #include  #include  #include  template std::ostream &operator<<(std::ostream &stream, const std::chrono::time_point &time_point) { const time_t time = Clock::to_time_t(time_point); #if __GNUC__ > 4 || \ ((__GNUC__ == 4) && __GNUC_MINOR__ > 8 && __GNUC_REVISION__ > 1) // Maybe the put_time will be implemented later? struct tm tm; localtime_r(&time, &tm); return stream << std::put_time(&tm, "%c"); // Print standard date&time #else char buffer[26]; ctime_r(&time, buffer); buffer[24] = '\0'; // Removes the newline that is added return stream << buffer; #endif } int main() { std::cout << std::chrono::system_clock::now() << std::endl; // Wed May 22 14:17:03 2013 } 

Les nanoseconds semblent faire partie du problème, en regardant un peu la documentation, j’ai pu faire fonctionner ceci:

 #include  #include  #include  int main(){ //set time_point to current time std::chrono::time_point time_point; time_point = std::chrono::system_clock::now(); std::time_t ttp = std::chrono::system_clock::to_time_t(time_point); std::cout << "time: " << std::ctime(&ttp); return 0; } 

Bien qu'il semble que std::chrono::microseconds fonctionne bien:

 std::chrono::time_point time_point; 

Réponse mise à jour pour une ancienne question:

Pour un std::chrono::time_point il existe maintenant une bibliothèque tierce qui vous std::chrono::time_point meilleur contrôle. Pour les time_points basés sur d’autres horloges, il n’y a toujours pas de meilleure solution que d’obtenir simplement la représentation interne et de l’imprimer.

Mais pour system_clock , en utilisant cette bibliothèque , c’est aussi simple que:

 #include "date.h" #include  int main() { using namespace date; using namespace std::chrono; std::cout << system_clock::now() << " UTC\n"; } 

qui vient de sortir pour moi:

 2016-07-19 03:21:01.910626 UTC 

qui est la date et l'heure UTC actuelles avec une précision de la microseconde. Si sur votre plate-forme system_clock::time_point a une précision de nanoseconde, il imprimera une précision à la nanoseconde.

Pour toute personne travaillant avec time_point (pas time_point ):

 #include  #include  template std::ostream &operator<<( std::ostream &stream, const std::chrono::duration< std::intmax_t, std::ratio > &duration) { const std::intmax_t ticks = duration.count(); stream << (ticks / resolution) << '.'; std::intmax_t div = resolution; std::intmax_t frac = ticks; for (;;) { frac %= div; if (frac == 0) break; div /= 10; stream << frac / div; } return stream; } template std::ostream &operator<<( std::ostream &stream, const std::chrono::time_point &timepoint) { typename Duration::duration ago = timepoint.time_since_epoch(); return stream << ago; } int main(){ // print time_point std::chrono::time_point now = std::chrono::steady_clock::now(); std::cout << now << "\n"; // print duration (such as the difference between 2 time_points) std::chrono::steady_clock::duration age = now - now; std::cout << age << "\n"; } 

Le formateur de nombre décimal n'est pas le plus efficace, mais ne nécessite aucune connaissance préalable du nombre de décimales, ce qui n'est pas connu si vous souhaitez que la resolution soit basée sur un modèle, à moins que vous ne trouviez une expression constante ceil(log10(resolution)) .

Le ctime () ne fonctionne pas pour Visual C ++. J’utilise MS Visual Studio 2013. J’ai modifié le code ci-dessus pour utiliser ctime_s (…), comme demandé par le compilateur MSVC. Ça a marché.

 //set time_point to current time std::chrono::time_point time_point; time_point = std::chrono::system_clock::now(); std::time_t ttp = std::chrono::system_clock::to_time_t(time_point); char chr[50]; errno_t e = ctime_s(chr, 50, &ttp); if (e) std::cout << "Error." << std::endl; else std::cout << chr << std::endl;