Extrait année/mois/jour, etc. de std::chrono::time_point en C++

Vous ne pouvez extraire cette information à partir d'un system_clock::time_point. C'est le seul fourni par le système de l'horloge qui a une relation avec le calendrier civil. Voici comment obtenir le courant time_point à l'aide de cette horloge:

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

Vous pouvez ensuite convertir cette time_t avec:

time_t tt = system_clock::to_time_t(now);

À l'aide de la bibliothèque C, vous pouvez convertir en un time_t à un tm, mais vous devez choisir si vous voulez que la conversion à se produire dans le fuseau horaire UTC, ou vous le fuseau horaire local:

tm utc_tm = *gmtime(&tt);
tm local_tm = *localtime(&tt);

Ensuite, vous pouvez imprimer les composants de la tm, par exemple:

std::cout << local_tm.tm_year + 1900 << '\n';
std::cout << local_tm.tm_mon + 1 << '\n';
std::cout << local_tm.tm_mday << '\n';

En outre

Si vous le souhaitez, vous pouvez profiter de cette situation de non-garantie de l'information:

Chaque mise en œuvre de system_clock je suis au courant est basé sur le temps unix. I. e. le nombre de secondes depuis le de Nouvelles Années 1970 UTC, en négligeant les secondes intercalaires. Et la précision de ce nombre est généralement de moins de secondes. Voici un programme complet qui extrait l'ensemble de ces informations:

#include <chrono>
#include <ctime>
#include <iostream>
int
main()
{
using namespace std;
using namespace std::chrono;
typedef duration<int, ratio_multiply<hours::period, ratio<24> >::type> days;
system_clock::time_point now = system_clock::now();
system_clock::duration tp = now.time_since_epoch();
days d = duration_cast<days>(tp);
tp -= d;
hours h = duration_cast<hours>(tp);
tp -= h;
minutes m = duration_cast<minutes>(tp);
tp -= m;
seconds s = duration_cast<seconds>(tp);
tp -= s;
std::cout << d.count() << "d " << h.count() << ':'
<< m.count() << ':' << s.count();
std::cout << " " << tp.count() << "["
<< system_clock::duration::period::num << '/'
<< system_clock::duration::period::den << "]\n";
time_t tt = system_clock::to_time_t(now);
tm utc_tm = *gmtime(&tt);
tm local_tm = *localtime(&tt);
std::cout << utc_tm.tm_year + 1900 << '-';
std::cout << utc_tm.tm_mon + 1 << '-';
std::cout << utc_tm.tm_mday << ' ';
std::cout << utc_tm.tm_hour << ':';
std::cout << utc_tm.tm_min << ':';
std::cout << utc_tm.tm_sec << '\n';
}

Il est pratique de créer un personnalisé duration de modèle de jours:

typedef duration<int, ratio_multiply<hours::period, ratio<24> >::type> days;

Maintenant, vous pouvez prendre le temps depuis l'époque, pour que la fine de précision, car il peut gérer, avec:

system_clock::duration tp = now.time_since_epoch();

Puis tronquer à jours, et soustrayez-off.

Puis tronquer à heures, et soustrayez-off.

Continuer jusqu'à ce que vous avez soustrait les secondes.

Ce que vous êtes de gauche avec la fraction de seconde avec les unités de system_clock::duration. Afin d'impression que de l'exécution de la valeur et de la durée de la compilation des unités de valeur.

Pour moi ce programme imprime:

15806d 20:31:14 598155[1/1000000]
2013-4-11 20:31:14

Ma sortie indique le system_clock::duration la précision est de quelques microsecondes. Si désiré, qui peut être tronqué à quelques millisecondes avec:

milliseconds ms = duration_cast<milliseconds>(tp);

Mise à jour

Cette tête de C++11/14 bibliothèque encapsule le travail ci-dessus, la réduction de travail du client vers:

#include "date.h"
#include <iostream>
int
main()
{
//Reduce verbosity but let you know what is in what namespace
namespace C = std::chrono;
namespace D = date;
namespace S = std;
auto tp = C::system_clock::now(); //tp is a C::system_clock::time_point
{
//Need to reach into namespace date for this streaming operator
using namespace date;
S::cout << tp << '\n';
}
auto dp = D::floor<D::days>(tp);  //dp is a sys_days, which is a
//type alias for a C::time_point
auto ymd = D::year_month_day{dp};
auto time = D::make_time(C::duration_cast<C::milliseconds>(tp-dp));
S::cout << "year        = " << ymd.year() << '\n';
S::cout << "month       = " << ymd.month() << '\n';
S::cout << "day         = " << ymd.day() << '\n';
S::cout << "hour        = " << time.hours().count() << "h\n";
S::cout << "minute      = " << time.minutes().count() << "min\n";
S::cout << "second      = " << time.seconds().count() << "s\n";
S::cout << "millisecond = " << time.subseconds().count() << "ms\n";
}

Qui vient de sortie pour moi:

2015-07-10 20:10:36.023017
year        = 2015
month       = Jul
day         = 10
hour        = 20h
minute      = 10min
second      = 36s
millisecond = 23ms

Une Autre Mise À Jour

Cette bibliothèque a grandi en C++ proposition de normes et est maintenant dans le C++20 projet de travail. La syntaxe pour l'extraction de ces champs à partir d'une system_clock::time_point en C++20 sera:

#include <chrono>
int
main()
{
using namespace std::chrono;
auto tp = system_clock::now();
auto dp = floor<days>(tp);
year_month_day ymd{dp};
hh_mm_ss time{floor<milliseconds>(tp-dp)};
auto y = ymd.year();
auto m = ymd.month();
auto d = ymd.day();
auto h = time.hours();
auto M = time.minutes();
auto s = time.seconds();
auto ms = time.subseconds();
}

Ci-dessus suppose que vous voulez ces champs en UTC. Si vous préférez, dans un autre fuseau horaire, qui sera également possible. Par exemple, voici comment le faire dans votre ordinateur local time zone:

#include <chrono>
int
main()
{
using namespace std::chrono;
auto tp = zoned_time{current_zone(), system_clock::now()}.get_local_time();
auto dp = floor<days>(tp);
year_month_day ymd{dp};
hh_mm_ss time{floor<milliseconds>(tp-dp)};
auto y = ymd.year();
auto m = ymd.month();
auto d = ymd.day();
auto h = time.hours();
auto M = time.minutes();
auto s = time.seconds();
auto ms = time.subseconds();
}

La seule différence ci-dessus est la construction de tp qui dispose désormais d'un type local_time par opposition à sys_time dans l'heure UTC exemple. Sinon on aurait pris un temps arbitraire zone avec ce petit changement:

auto tp = zoned_time{"Europe/London", system_clock::now()}.get_local_time();