Namespaces
Variants

std::chrono:: duration

From cppreference.net
C++
Date and time library
std::chrono::duration
Member functions
Non-member functions
Helper classes
Défini dans l'en-tête <chrono>
template <

class Rep,
class Period = std:: ratio < 1 >

> class duration ;
(depuis C++11)

Le modèle de classe std::chrono::duration représente un intervalle de temps.

Il se compose d'un nombre de ticks de type Rep et d'une période de tick, où la période de tick est une fraction rationnelle fraction à la compilation représentant le temps en secondes entre deux ticks consécutifs.

Les seules données stockées dans une duration sont un nombre de ticks de type Rep . Si Rep est un type à virgule flottante, alors la duration peut représenter des fractions de ticks. Period est inclus comme partie du type de la durée, et n'est utilisé que lors de conversions entre différentes durées.

Table des matières

Types membres

Type de membre Définition
rep Rep , un type arithmétique, ou une classe émulant un type arithmétique, représentant le nombre de ticks
period Period (jusqu'en C++17) typename Period :: type (depuis C++17) , un std::ratio représentant la période du tick (c'est-à-dire le nombre de fractions de seconde par tick)

Fonctions membres

construit une nouvelle durée
(fonction membre publique)
assigne le contenu
(fonction membre publique)
retourne le nombre de ticks
(fonction membre publique)
[static]
retourne la valeur spéciale de durée zéro
(fonction membre statique publique)
[static]
retourne la valeur spéciale de durée min
(fonction membre statique publique)
[static]
retourne la valeur spéciale de durée max
(fonction membre statique publique)
implémente les opérateurs unaires + et -
(fonction membre publique)
incrémente ou décrémente le nombre de ticks
(fonction membre publique)
implémente l'assignation composée entre deux durées
(fonction membre publique)

Fonctions non membres

(C++11)
implémente les opérations arithmétiques avec des durées comme arguments
(modèle de fonction)
(C++11) (C++11) (supprimé en C++20) (C++11) (C++11) (C++11) (C++11) (C++20)
compare deux durées
(modèle de fonction)
(C++11)
convertit une durée en une autre, avec un intervalle de ticks différent
(modèle de fonction)
(C++17)
convertit une durée en une autre, en arrondissant vers le bas
(modèle de fonction)
(C++17)
convertit une durée en une autre, en arrondissant vers le haut
(modèle de fonction)
(C++17)
convertit une durée en une autre, en arrondissant au plus proche, les égalités vers le pair
(modèle de fonction)
(C++17)
obtient la valeur absolue de la durée
(modèle de fonction)
(C++20)
effectue une sortie de flux sur une duration
(modèle de fonction)
(C++20)
analyse une duration depuis un flux selon le format fourni
(modèle de fonction)

Types auxiliaires

Un type /* intXX */ utilisé dans le tableau ci-dessous signifie un type entier signé d'au moins XX bits.

Type Définition
std::chrono::nanoseconds std :: chrono :: duration < /* int64 */ , std:: nano >
std::chrono::microseconds std :: chrono :: duration < /* int55 */ , std:: micro >
std::chrono::milliseconds std :: chrono :: duration < /* int45 */ , std:: milli >
std::chrono::seconds std :: chrono :: duration < /* int35 */ >
std::chrono::minutes std :: chrono :: duration < /* int29 */ , std:: ratio < 60 >>
std::chrono::hours std :: chrono :: duration < /* int23 */ , std:: ratio < 3600 >>
std::chrono::days (depuis C++20) std :: chrono :: duration < /* int25 */ , std:: ratio < 86400 >>
std::chrono::weeks (depuis C++20) std :: chrono :: duration < /* int22 */ , std:: ratio < 604800 >>
std::chrono::months (depuis C++20) std :: chrono :: duration < /* int20 */ , std:: ratio < 2629746 >>
std::chrono::years (depuis C++20) std :: chrono :: duration < /* int17 */ , std:: ratio < 31556952 >>

Note : chaque type de durée prédéfini jusqu'à hours couvre une plage d'au moins ±292 ans.

Chacun des types de durée prédéfinis days , weeks , months et years couvre une plage d'au moins ±40000 ans. years est égal à 365,2425 days (la longueur moyenne d'une année grégorienne). months est égal à 30,436875 days (exactement 1/12 de years ).

(depuis C++20)

Classes d'assistance

(C++11)
spécialise le trait std::common_type
(spécialisation de modèle de classe)
(C++11)
indique qu'une durée est convertible en durée avec une période de tick différente
(modèle de classe)
(C++11)
construit les valeurs zéro, min et max d'un compteur de ticks d'un type donné
(modèle de classe)
(C++20)
support de formatage pour duration
(spécialisation de modèle de classe)
(C++26)
support de hachage pour std::chrono::duration
(spécialisation de modèle de classe)

Spécialisations d'assistance

template < class Rep, class Period >

constexpr bool enable_nonlocking_formatter_optimization < chrono :: duration < Rep, Period >>

= enable_nonlocking_formatter_optimization < Rep > ;
(depuis C++23)

Cette spécialisation de std::enable_nonlocking_formatter_optimization permet une implémentation efficace de std::print et std::println pour l'affichage d'un objet chrono::duration lorsque le paramètre template Rep le permet.

Littéraux

Défini dans l'espace de noms en ligne std::literals::chrono_literals
(C++14)
un littéral std::chrono::duration représentant des heures
(fonction)
(C++14)
un littéral std::chrono::duration représentant des minutes
(fonction)
(C++14)
un littéral std::chrono::duration représentant des secondes
(fonction)
(C++14)
un littéral std::chrono::duration représentant des millisecondes
(fonction)
(C++14)
un littéral std::chrono::duration représentant des microsecondes
(fonction)
(C++14)
un littéral std::chrono::duration représentant des nanosecondes
(fonction)

Note : les suffixes littéraux d et y ne font pas référence à days et years mais respectivement à day et year .

(depuis C++20)

Notes

L'intervalle de temps réel (en secondes) contenu par un objet de durée d est approximativement égal à d. count ( ) * D :: period :: num / D :: period :: den , où D est de type chrono::duration<> et d est un objet de ce type.

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_chrono_udls 201304L (C++14) Littéraux définis par l'utilisateur pour les types temporels

Exemple

Cet exemple montre comment définir plusieurs types de durée personnalisés et convertir entre les types :

Exécuter ce code 
#include <chrono>
#include <iostream>
using namespace std::chrono_literals;
template<typename T1, typename T2>
using mul = std::ratio_multiply<T1, T2>;
int main()
{
    using microfortnights = std::chrono::duration<float,
        mul<mul<std::ratio<2>, std::chrono::weeks::period>, std::micro>>;
    using nanocenturies = std::chrono::duration<float,
        mul<mul<std::hecto, std::chrono::years::period>, std::nano>>;
    using fps_24 = std::chrono::duration<double, std::ratio<1, 24>>;
    std::cout << "1 second is:\n";
    // integer scale conversion with no precision loss: no cast
    std::cout << std::chrono::milliseconds(1s).count() << " milliseconds\n"
              << std::chrono::microseconds(1s).count() << " microseconds\n"
              << std::chrono::nanoseconds(1s).count() << " nanoseconds\n";
    // integer scale conversion with precision loss: requires a cast
    std::cout << std::chrono::duration_cast<std::chrono::minutes>(1s).count()
              << " minutes\n";
    // alternative to duration_cast:
    std::cout << 1s / 1min << " minutes\n";
    // floating-point scale conversion: no cast
    std::cout << microfortnights(1s).count() << " microfortnights\n"
              << nanocenturies(1s).count() << " nanocenturies\n"
              << fps_24(1s).count() << " frames at 24fps\n";
}

Sortie : 

1 second is:
1000 milliseconds
1000000 microseconds
1000000000 nanoseconds
0 minutes
0 minutes
0.82672 microfortnights
0.316887 nanocenturies
24 frames at 24fps