Namespaces
Variants

std::chrono:: duration

From cppreference.net
C++
Date and time library
std::chrono::duration
Member functions
Non-member functions
Helper classes
Definiert im Header <chrono>
template <

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

> class duration ;
(seit C++11)

Klassentemplate std::chrono::duration repräsentiert ein Zeitintervall.

Es besteht aus einer Anzahl von Ticks des Typs Rep und einer Tick-Periode, wobei die Tick-Periode ein Compile-time rationaler fraction ist, der die Zeit in Sekunden von einem Tick zum nächsten darstellt.

Die einzigen in einem duration gespeicherten Daten sind ein Tick-Zähler vom Typ Rep . Wenn Rep ein Fließkommatyp ist, dann kann der duration Bruchteile von Ticks darstellen. Period ist Teil des Typs der Duration und wird nur bei Konvertierungen zwischen verschiedenen Duration-Typen verwendet.

Inhaltsverzeichnis

Mitgliedertypen

Mitgliedertyp Definition
rep Rep , ein arithmetischer Typ oder eine Klasse, die einen arithmetischen Typ emuliert, der die Anzahl der Ticks repräsentiert
period Period (bis C++17) typename Period :: type (seit C++17) , ein std::ratio , der die Tick-Periode repräsentiert (d.h. die Anzahl der Sekundenbruchteile pro Tick)

Memberfunktionen

Konstruiert neue Duration
(öffentliche Elementfunktion)
weist die Inhalte zu
(öffentliche Elementfunktion)
gibt die Anzahl der Ticks zurück
(öffentliche Elementfunktion)
[static]
gibt den speziellen Duration-Wert zero zurück
(öffentliche statische Elementfunktion)
[static]
gibt den speziellen Duration-Wert min zurück
(öffentliche statische Elementfunktion)
[static]
gibt den speziellen Duration-Wert max zurück
(öffentliche statische Elementfunktion)
implementiert unäres + und unäres -
(öffentliche Elementfunktion)
erhöht oder verringert die Tick-Anzahl
(öffentliche Elementfunktion)
implementiert zusammengesetzte Zuweisung zwischen zwei Durations
(öffentliche Elementfunktion)

Nicht-Member-Funktionen

(C++11)
implementiert arithmetische Operationen mit Dauern als Argumente
(Funktions-Template)
(C++11) (C++11) (entfernt in C++20) (C++11) (C++11) (C++11) (C++11) (C++20)
vergleicht zwei Dauern
(Funktions-Template)
(C++11)
konvertiert eine Dauer in eine andere mit einem anderen Taktintervall
(Funktions-Template)
(C++17)
konvertiert eine Dauer in eine andere, abgerundet
(Funktions-Template)
(C++17)
konvertiert eine Dauer in eine andere, aufgerundet
(Funktions-Template)
(C++17)
konvertiert eine Dauer in eine andere, gerundet auf den nächsten Wert, bei Gleichheit zur geraden Zahl
(Funktions-Template)
(C++17)
ermittelt den absoluten Wert der Dauer
(Funktions-Template)
(C++20)
führt Stream-Ausgabe auf einer duration durch
(Funktions-Template)
(C++20)
parst eine duration aus einem Stream gemäß dem bereitgestellten Format
(Funktions-Template)

Hilfstypen

Ein Typ /* intXX */ in der folgenden Tabelle bedeutet einen vorzeichenbehafteten Integer-Typ mit mindestens XX Bits.

Typ Definition
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 (seit C++20) std :: chrono :: duration < /* int25 */ , std:: ratio < 86400 >>
std::chrono::weeks (seit C++20) std :: chrono :: duration < /* int22 */ , std:: ratio < 604800 >>
std::chrono::months (seit C++20) std :: chrono :: duration < /* int20 */ , std:: ratio < 2629746 >>
std::chrono::years (seit C++20) std :: chrono :: duration < /* int17 */ , std:: ratio < 31556952 >>

Hinweis: Jeder der vordefinierten Zeitdauer-Typen bis zu hours deckt einen Bereich von mindestens ±292 Jahren ab.

Jeder der vordefinierten Duration-Typen days , weeks , months und years deckt einen Bereich von mindestens ±40000 Jahren ab. years entspricht 365,2425 days (der durchschnittlichen Länge eines gregorianischen Jahres). months entspricht 30,436875 days (exakt 1/12 von years ).

(since C++20)

Hilfsklassen

(C++11)
spezialisiert das std::common_type Merkmal
(Klassen-Template-Spezialisierung)
(C++11)
zeigt an, dass eine Dauer in eine Dauer mit anderem Taktperiodenwert konvertierbar ist
(Klassen-Template)
(C++11)
konstruiert Null-, Minimal- und Maximalwerte einer Tickanzahl eines gegebenen Typs
(Klassen-Template)
(C++20)
Formatierungsunterstützung für duration
(Klassen-Template-Spezialisierung)
(C++26)
Hash-Unterstützung für std::chrono::duration
(Klassen-Template-Spezialisierung)

Helfer-Spezialisierungen

template < class Rep, class Period >

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

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

Diese Spezialisierung von std::enable_nonlocking_formatter_optimization ermöglicht eine effiziente Implementierung von std::print und std::println für die Ausgabe eines chrono::duration Objekts, wenn der Template-Parameter Rep dies ermöglicht.

Literale

Definiert im Inline-Namensraum std::literals::chrono_literals
(C++14)
ein std::chrono::duration Literal für Stunden
(Funktion)
(C++14)
ein std::chrono::duration Literal für Minuten
(Funktion)
(C++14)
ein std::chrono::duration Literal für Sekunden
(Funktion)
(C++14)
ein std::chrono::duration Literal für Millisekunden
(Funktion)
(C++14)
ein std::chrono::duration Literal für Mikrosekunden
(Funktion)
(C++14)
ein std::chrono::duration Literal für Nanosekunden
(Funktion)

Hinweis: Die Literalsuffixe d und y beziehen sich nicht auf days und years , sondern bezeichnen jeweils day und year .

(seit C++20)

Hinweise

Das tatsächliche Zeitintervall (in Sekunden), das von einem Duration-Objekt d gehalten wird, ist ungefähr gleich d. count ( ) * D :: period :: num / D :: period :: den , wobei D vom Typ chrono::duration<> ist und d ein Objekt dieses Typs ist.

Feature-Test Makro Wert Std Feature
__cpp_lib_chrono_udls 201304L (C++14) Benutzerdefinierte Literale für Zeittypen

Beispiel

Dieses Beispiel zeigt, wie mehrere benutzerdefinierte Duration-Typen definiert und zwischen Typen konvertiert werden:

Diesen Code ausführen 
#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 Sekunde entspricht:\n";
    // Integer-Skalierungskonvertierung ohne Präzisionsverlust: Kein Cast erforderlich
    std::cout << std::chrono::milliseconds(1s).count() << " Millisekunden\n"
              << std::chrono::microseconds(1s).count() << " Mikrosekunden\n"
              << std::chrono::nanoseconds(1s).count() << " Nanosekunden\n";
    // Integer-Skalierungskonvertierung mit Präzisionsverlust: Erfordert einen Cast
    std::cout << std::chrono::duration_cast<std::chrono::minutes>(1s).count()
              << " Minuten\n";
    // Alternative zu duration_cast:
    std::cout << 1s / 1min << " Minuten\n";
    // Fließkomma-Skalierungskonvertierung: Kein Cast erforderlich
    std::cout << microfortnights(1s).count() << " Mikrofortnights\n"
              << nanocenturies(1s).count() << " Nanocenturies\n"
              << fps_24(1s).count() << " Frames bei 24fps\n";
}

Ausgabe: 

1 Sekunde entspricht:
1000 Millisekunden
1000000 Mikrosekunden
1000000000 Nanosekunden
0 Minuten
0 Minuten
0.82672 Mikrofortnights
0.316887 Nanocenturies
24 Frames bei 24fps