Comment puis-je extraire les composants temporels d'un objet `std::chrono::time_point` ?

Extraire les composants temporels de std::chrono::time_point

Objectif : Acquérir l'année, le mois, le jour, l'heure, la minute, la seconde , et millisecondes à partir d'un std::chrono::time_point objet.

Solution :

Pour extraire ces informations, vous avez spécifiquement besoin d'un system_clock::time_point, fournissant une relation avec le système de calendrier civil.

<code class="cpp">using namespace std::chrono;
system_clock::time_point now = system_clock::now();</code>

L'étape suivante consiste à le convertir en time_t en utilisant :

<code class="cpp">time_t tt = system_clock::to_time_t(now);</code>

Utiliser la bibliothèque C pour convertir time_t à tm, en vous assurant que le bon fuseau horaire est choisi :

<code class="cpp">tm utc_tm = *gmtime(&amp;tt);
tm local_tm = *localtime(&amp;tt);</code>

Maintenant, vous pouvez extraire les composants de tm :

<code class="cpp">std::cout << local_tm.tm_year + 1900 << '\n';
std::cout << local_tm.tm_mon + 1 << '\n';
std::cout << local_tm.tm_mday << '\n';

Extraction des composants de l'horloge système

De plus, si vous préférez, vous pouvez vous appuyer sur l'approche non garantie suivante :

Chaque implémentation de system_clock connue de la plupart est basé sur l'heure Unix (le nombre de secondes depuis le 1er janvier 1970 UTC), généralement avec une précision plus fine que les secondes.

Le programme complet suivant fournit un exemple d'extraction de tous les composants temporels :

<code class="cpp">#include <chrono>
#include <ctime>
#include <iostream>

int main() {
  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(&amp;tt);
  tm local_tm = *localtime(&amp;tt);
  std::cout << utc_tm.tm_year + 1900 <&lt '-';
  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';
}</code>

Utiliser une durée personnalisée

Pour modéliser des jours, créez une durée personnalisée :

<code class="cpp">typedef duration<int, ratio_multiply<hours::period, ratio<24> >::type> days;</code>

Vous pouvez désormais obtenez l'heure depuis l'époque avec la précision de system_clock::duration :

<code class="cpp">system_clock::duration tp = now.time_since_epoch();</code>

Tronquez-le en jours et soustrayez-le :

<code class="cpp">days d = duration_cast<days>(tp);
tp -= d;</code>

Répétez ce processus pendant des heures, des minutes et des secondes .

Le reste est la fraction de seconde en unités de system_clock::duration.

Utilisation d'une bibliothèque de dates

Cette bibliothèque C 11/14 rationalise le processus ci-dessus :

<code class="cpp">#include "date.h"
#include <iostream>

int main() {
  using C = std::chrono;
  using D = date;
  using S = std;

  auto tp = C::system_clock::now();
  {
    using namespace date;
    S::cout << tp << '\n';
  }
  auto dp = D::floor<D::days>(tp);
  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";
}

Prise en charge de la bibliothèque standard C 20

C 20 introduit une syntaxe standardisée pour extraire ces champs d'un system_clock::time_point:

<code class="cpp">#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();
}</code>

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!