struct `steady_clock`

Article
10/12/2023

Représente une horloge qui n’est jamais ajustée et qui avance à un rythme uniforme.

Syntaxe

struct steady_clock;

Notes

Il steady_clock s’agit d’une horloge monotonique, ce qui signifie que le temps qu’il signale n’avance que vers l’avant. La valeur retournée par un appel à now est toujours inférieure ou égale à la valeur retournée par l’appel suivant à now.

Cela steady_clock garantit que le temps entre les cycles est constant, ce qui le rend mieux pour mesurer les intervalles que l’utilisation d’une horloge système. L’horloge système fournit l’heure du mur. Le problème lié à l’utilisation de l’horloge murale pour mesurer le temps écoulé est que l’heure de l’horloge murale peut être modifiée lors de la mesure d’un intervalle de temps. Il peut être modifié en synchronisant avec une autre horloge sur le réseau, par une transition vers l’heure d’été, et ainsi de suite. Un steady_clock n’est pas soumis à ces ajustements, ce qui en fait le moyen préféré de suivre le temps écoulé.

high_resolution_clock est un typedef pour steady_clock. Sur Windows, steady_clock encapsule la QueryPerformanceCounter fonction.

Exemple

#include <chrono> 
#include <thread>
#include <iostream>

using namespace std::chrono;

int main()
{
    auto begin = steady_clock::now();
    std::this_thread::sleep_for(std::chrono::seconds(1));
    auto end = steady_clock::now();
    
    std::cout << "Elapsed seconds:      "
        << duration_cast<seconds>(end - begin).count()
        << "s\n";

    std::cout << "Elapsed milliseconds: "
        << duration_cast<milliseconds>(end - begin).count()
        << "ms\n";

    std::cout << "Elapsed microseconds: "
        << duration_cast<microseconds>(end - begin).count()
        << "us\n";

    std::cout << "Elapsed nanoseconds:  "
        << duration_cast<nanoseconds>(end - begin).count()
        << " ns\n";

    return 0;
}

Elapsed seconds:      1s
Elapsed milliseconds: 1007ms
Elapsed microseconds: 1007266us
Elapsed nanoseconds:  1007266700 ns

Alias de type pratique

Nom	Description
`steady_clock::duration`	Dans l’implémentation de Microsoft, il s’agit d’un synonyme pour `nanoseconds`, qui est défini comme `duration<long long, nano>`. Il représente une durée mesurée en milliards de secondes.
`steady_clock::period`	Dans l’implémentation de Microsoft, il s’agit d’un synonyme pour `nano`, qui est défini comme `std::ratio<1i64, 1000000000i64>` . Il représente le temps en secondes (un milliardième de seconde) entre chaque graduation dans la durée.
`steady_clock::rep`	Synonyme de `long long`, qui est le type utilisé dans l’implémentation Microsoft pour représenter le nombre de cycles d’horloge dans un `steady_clock::duration`
`steady_clock::time_point`	Synonyme de `time_point<steady_clock>`. Utilisé pour représenter une `time_point` horloge.

Fonctions publiques

Fonction	Description
`now`	Retourne l’heure actuelle à partir de la `steady_clock` valeur.`time_point`

Constantes publiques

Nom	Description
`steady_clock::is_steady`	Contient `true`. Un `steady_clock` est steady. Cela signifie que vous pouvez utiliser cette horloge pour obtenir l’heure avant un événement, l’heure après un événement et les soustraire de manière fiable pour obtenir la durée de l’événement, car l’horloge ne sera pas ajustée pendant cette heure.

Spécifications

En-tête : <chrono>

Espace de noms : std::chrono

Voir aussi

<chrono>
file_clock class
high_resolution_clock
Struct local_t
Struct system_clock
tai_clock, classe
utc_clock, classe
Informations de référence sur les fichiers d’en-tête

Partager via