Namespaces
Variants

std::chrono:: time_point

From cppreference.net
C++
Date and time library
std::chrono::time_point
Défini dans l'en-tête <chrono>
template <

class Clock,
class Duration = typename Clock :: duration

> class time_point ;
(depuis C++11)

Le modèle de classe std::chrono::time_point représente un point dans le temps. Il est implémenté comme s'il stockait une valeur de type Duration indiquant l'intervalle de temps depuis le début de l'époque de l'horloge Clock .

Clock doit satisfaire aux exigences pour Clock ou être std::chrono::local_t (depuis C++20) .

(jusqu'à C++23)

Table des matières

Types membres

Type Description
Clock clock
l'horloge sur laquelle ce point temporel est mesuré
(typedef)
Duration duration
un type std::chrono::duration utilisé pour mesurer le temps depuis l'époque
(typedef)
duration::rep rep
un type arithmétique représentant le nombre de ticks de la durée
(typedef)
duration::period period
un type std::ratio représentant la période de tick de la durée
(typedef)

Fonctions membres

construit un nouveau point temporel
(fonction membre publique)
retourne le point temporel comme durée depuis le début de son horloge
(fonction membre publique)
modifie le point temporel par la durée donnée
(fonction membre publique)
(C++20)
incrémente ou décrémente la durée
(fonction membre publique)
[static]
retourne le point temporel correspondant à la plus petite durée
(fonction membre statique publique)
[static]
retourne le point temporel correspondant à la plus grande durée
(fonction membre statique publique)

Fonctions non membres

(C++11)
effectue des opérations d'addition et de soustraction impliquant un point temporel
(modèle de fonction)
(C++11) (C++11) (supprimé en C++20) (C++11) (C++11) (C++11) (C++11) (C++20)
compare deux points temporels
(modèle de fonction)
(C++11)
convertit un point temporel en un autre point temporel sur la même horloge, avec une durée différente
(modèle de fonction)
(C++17)
convertit un time_point en un autre, en arrondissant vers le bas
(modèle de fonction)
(C++17)
convertit un time_point en un autre, en arrondissant vers le haut
(modèle de fonction)
(C++17)
convertit un time_point en un autre, en arrondissant au plus proche, les égalités vers le pair
(modèle de fonction)

Classes d'assistance

(C++11)
spécialise le trait std::common_type
(spécialisation de modèle de classe)
(C++26)
support de hachage pour std::chrono::time_point
(spécialisation de modèle de classe)

Exemple

Exécuter ce code 
#include <algorithm>
#include <chrono>
#include <ctime>
#include <iomanip>
#include <iostream>
void slow_motion()
{
    static int a[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
    // Génère Γ(13) == 12! permutations :
    while (std::ranges::next_permutation(a).found) {}
}
int main()
{
    using namespace std::literals; // active les suffixes littéraux, par ex. 24h, 1ms, 1s.
    const std::chrono::time_point<std::chrono::system_clock> now =
        std::chrono::system_clock::now();
    const std::time_t t_c = std::chrono::system_clock::to_time_t(now - 24h);
    std::cout << "Il y a 24 heures, l'heure était "
              << std::put_time(std::localtime(&t_c), "%F %T.\n") << std::flush;
    const std::chrono::time_point<std::chrono::steady_clock> start =
        std::chrono::steady_clock::now();
    std::cout << "Les horloges différentes ne sont pas comparables : \n"
                 "  Temps système : " << now.time_since_epoch() << "\n"
                 "  Temps stable : " << start.time_since_epoch() << '\n';
    slow_motion();
    const auto end = std::chrono::steady_clock::now();
    std::cout
        << "Les calculs lents ont pris "
        << std::chrono::duration_cast<std::chrono::microseconds>(end - start) << " ≈ "
        << (end - start) / 1ms << "ms ≈ " // forme presque équivalente de la précédente, mais
        << (end - start) / 1s << "s.\n";  // utilisant respectivement les millisecondes et les secondes
}

Sortie possible : 

Il y a 24 heures, l'heure était 2021-02-15 18:28:52.
Les horloges différentes ne sont pas comparables :
  Temps système : 1666497022681282572ns
  Temps stable : 413668317434475ns
Les calculs lents ont pris 2090448µs ≈ 2090ms ≈ 2s.

Voir aussi

(C++11)
un intervalle de temps
(modèle de classe)
(C++20)
représente une year , month et day spécifiques
(classe)