Classe duration

Mesure un intervalle de temps tel qu’une minute, deux heures, dix millisecondes, etc.

Un duration intervalle de temps est un intervalle de temps, qui correspond au nombre de graduations sur une unité de temps. Par exemple, cinq minutes sont cinq cycles, chaque graduation étant séparée par minute. 42 secondes sont 42 cycles, chaque graduation étant séparée par une seconde.

Syntaxe

template <class Rep, class Period> class duration;
template <class Rep, class Period = ratio<1>> class duration;
template <class Rep, class Period1, class Period2> class duration <duration<Rep, Period1>, Period2>;

Notes

L’argument de modèle Rep décrit le type utilisé pour contenir le nombre de battements d’horloge dans l’intervalle. L’argument Period de modèle est une instanciation de ratio ce qui décrit la taille de l’intervalle que chaque graduation représente.

Membres

Constructeurs

Functions

Opérateurs

Non-membres

Modèles de fonctions

Opérateurs

Alias de type pratique

Spécifications

En-tête : <chrono>

Espace de noms : std::chrono

duration::count

Récupère le nombre de battements d'horloge dans l'intervalle de temps.

constexpr Rep count() const;

Valeur retournée

Nombre de battements d'horloge dans l'intervalle de temps.

Constructeur duration::duration

Construit un objet duration.

1) constexpr duration() = default;
2) constexpr duration(const duration& d) = default;

3) template <class Rep2>
constexpr explicit duration(const Rep2& R);

4) template <class Rep2, class Period2>
constexpr duration(const duration<Rep2, Period2>& Dur);

Paramètres

Dur
Nombre de battements de la période spécifiée par Period2.

Period2
Spécialisation de modèle std::ratio pour représenter la période de battements en unités de secondes.

R
Nombre de battements de la période par défaut.

Rep2
Type arithmétique pour représenter le nombre de battements.

Notes

1) Le constructeur par défaut construit un objet non initialisé. L’initialisation de valeurs à l’aide d’accolades vides initialise un objet qui représente un intervalle de temps de zéro battement d’horloge.

2) Le constructeur de copie effectue une copie au niveau du bit .d

3) Construit un objet qui représente un intervalle de temps de cycles d’horloge R à l’aide d’une période par défaut de std::ratio<1>. Pour éviter l’arrondi des nombres de graduations, il s’agit d’une erreur de construction d’un objet de durée à partir d’un type Rep2 de représentation qui peut être traité comme un type à virgule flottante lorsqu’il duration::rep ne peut pas être traité comme un type à virgule flottante.

4) Construit un objet qui représente un intervalle de temps dont la longueur est l’intervalle de temps spécifié par Dur. Pour éviter la troncation des nombres de cycles, il s’agit d’une erreur de construction d’un objet de durée à partir d’un autre objet de durée dont le type est incommensurable avec le type cible.

Un type D1 de durée est incommensurable avec un autre type D2 de durée s’il D2 ne peut pas être traité comme un type à virgule flottante et ratio_divide<D1 ::p eriod, D2 ::p eriod> ::type ::d en n’est pas 1.

Sauf s’il Rep2 est implicitement convertible en rep et treat_as_floating_point<rep>contient la valeur true ou treat_as_floating_point<Rep2>contient false, le deuxième constructeur ne participe pas à la résolution de surcharge. Pour plus d’informations, consultez <type_traits>.

Sauf si aucun dépassement de capacité n’est induit dans la conversion et treat_as_floating_point<rep>a la valeur true, ou les deux ratio_divide<Period2, period>::den est égal à 1 et treat_as_floating_point<Rep2>contient false, le troisième constructeur ne participe pas à la résolution de surcharge. Pour plus d’informations, consultez <type_traits>.

Exemple : Créer un duration

// compile using: /std:c++latest
#include <iostream>
#include <chrono>

using namespace std::chrono;

int main()
{
    // create a duration that tracks ticks as 1/10ths of a second
    duration<int, std::ratio<1, 10>> tenths{ 5 };
    std::cout << tenths << '\n';

    hours h{12}; // hours is a convenience duration typedef 
    auto h2 = 3h; // 'h' is a convenience operator. h2 is a duration<int, std::ratio<3600,1>>

    std::cout << h << ":" << h2 << '\n';

    return 0;
}

5ds
3h:3h

duration::max

Méthode statique qui retourne la limite supérieure des valeurs du type de paramètre de modèle Rep.

static constexpr duration max();

Valeur retournée

Retourne duration(duration_values<rep>::max()).

duration::min

Méthode statique qui retourne la limite inférieure des valeurs du type de paramètre de modèle Rep.

static constexpr duration min();

Valeur retournée

Retourne duration(duration_values<rep>::min()).

duration::operator-

Retourne une copie de l’objet duration avec un nombre de graduations négation.

constexpr duration operator-() const;

duration::operator--

Décrémente le nombre de battements stocké.

1) duration& operator--();
2) duration operator--(int);

Valeur retournée

1) Renvoie *this. 2) Retourne une copie avant *this la décrémentation.

duration::operator%=

Réduit le nombre de cycles stocké modulo la valeur spécifiée.

1) duration& operator%=(const rep& Div);
2) duration& operator%=(const duration& Div);

Paramètres

Div
1) Div un nombre de graduations. 2) Div un duration qui contient un nombre de graduations.

Valeur retournée

Objet duration après l’opération modulo.

duration::operator*=

Multiplie le nombre de battements stocké par une valeur spécifiée.

duration& operator*=(const rep& Mult);

Paramètres

Mult
Valeur du type spécifié par duration::rep.

Valeur retournée

Objet duration après la multiplication.

duration::operator/=

Divise le nombre de battements stocké par une valeur spécifiée.

duration& operator/=(const rep& Div);

Paramètres

Div
Valeur du type spécifié par duration::rep.

Valeur retournée

Objet duration une fois la division terminée.

duration::operator+

Retourne *this.

constexpr duration operator+() const;

Valeur retournée

*this

duration::operator++

Incrémente le nombre de battements stocké.

1) duration& operator++();
2) duration operator++(int);

Valeur retournée

1) Renvoie *this. 2) Retourne une copie avant *this l’incrément.

duration::operator+=

Ajoute le nombre de battements d’un objet duration spécifié au nombre de battements stocké.

duration& operator+=(const duration& Dur);

Paramètres

Dur
Objet duration.

Valeur retournée

Objet duration après l’ajout.

duration::operator-=

Soustrait le nombre de battements d’un objet duration spécifié du nombre de battements stocké.

duration& operator-=(const duration& Dur);

Paramètres

Dur
Objet duration.

Valeur retournée

Objet duration après la soustraction.

duration::zero

Retourne duration(duration_values<rep>::zero()).

static constexpr duration zero();

duration::operator=

Affecte une durée à une autre.

duration& operator=(const duration &other) = default;

Paramètres

other
Objet duration à copier.

Valeur retournée

Objet LHS duration .

Voir aussi

<chrono>
Typesdefs pratiques duration tels que minutes, secondset bien plus encore
Littéraux pratiques pendant des heures, des minutes et bien plus encore
Structure duration_values
Informations de référence sur les fichiers d’en-tête