std::chrono::duration

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Datums- und Zeitbibliothek

Zeitpunkt time_point (C++11) clock_time_conversion (C++20)   clock_cast (C++20) Dauer duration (C++11) Uhren system_clock (C++11) steady_clock (C++11) is_clock (C++20) utc_clock (C++20) tai_clock (C++20) high_resolution_clock (C++11) gps_clock (C++20) file_clock (C++20) local_t (C++20) Tageszeit is_amis_pm (C++20)(C++20) make12make24 (C++20)(C++20) hh_mm_ss (C++20)

Kalender day (C++20) month (C++20) year (C++20) weekday (C++20) operator/ (C++20) year_month_day (C++20) year_month_day_last (C++20) year_month_weekday (C++20) year_month_weekday_last (C++20)   weekday_indexed (C++20) weekday_last (C++20) month_day (C++20) month_day_last (C++20) month_weekday (C++20) month_weekday_last (C++20) year_month (C++20) last_speclast (C++20)(C++20) chrono E/A parse (C++20)

Zeitzone tzdb (C++20) tzdb_list (C++20) get_tzdbget_tzdb_listreload_tzdbremote_version (C++20)(C++20)(C++20)(C++20) sys_info (C++20) local_info (C++20) nonexistent_local_time (C++20) ambiguous_local_time (C++20) locate_zone (C++20) current_zone (C++20) time_zone (C++20) choose (C++20) zoned_traits (C++20) zoned_time (C++20) time_zone_link (C++20) leap_second (C++20) leap_second_info (C++20) get_leap_second_info (C++20) C-Stil Datums- und Zeitfunktionen

 

std::chrono::duration

Memberfunktionen
duration::duration duration::operator= duration::count duration::zero duration::min duration::max duration::operator+duration::operator-	duration::operator++duration::operator-- duration::operator+=duration::operator-=duration::operator*=duration::operator/=duration::operator%=
Nicht-Member-Funktionen
operator+operator-operator*operator/operator% operator==operator!=operator<operator<=operator>operator>=operator<=> (bis C++20)(C++20) operator<< (C++20)	duration_cast floor (C++17) ceil (C++17) round (C++17) abs (C++17) operator""h (C++14) operator""min (C++14) operator""s (C++14) operator""ms (C++14) operator""us (C++14) operator""ns (C++14) from_stream (C++20)
Hilfsklassen
common_type treat_as_floating_point      duration_values	formatter<std::chrono::duration> (C++20) hash<std::chrono::duration> (C++26)

 

Definiert in Header <chrono>
template<     class Rep,     class Period = std::ratio<1> > class duration;		(seit C++11)

Die Klasse std::chrono::duration repräsentiert ein Zeitintervall.

Sie besteht aus einer Anzahl von Ticks vom Typ Rep und einer Tick-Periode, wobei die Tick-Periode ein rationaler Bruch zur Kompilierzeit ist, der die Zeit in Sekunden von einem Tick zum nächsten repräsentiert (fraction).

Die einzige in einer duration gespeicherte Information ist die Tick-Anzahl vom Typ Rep. Wenn Rep ein Fließkommatyp ist, kann die duration Bruchteile von Ticks darstellen. Period ist Teil des Typs der duration und wird nur beim Konvertieren zwischen verschiedenen durations verwendet.

Member types

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).

Member functions

(Konstruktor)	erstellt eine neue duration (public member function)
operator=	weist den Inhalt zu (public member function)
zählt	gibt die Anzahl der Ticks zurück (public member function)
null [static]	gibt den speziellen duration-Wert null zurück (public static member function)
min [static]	gibt den speziellen duration-Wert min zurück (public static member function)
max [static]	gibt den speziellen duration-Wert max zurück (public static member function)
operator+operator-	implementiert unäres + und unäres - (public member function)
operator++operator++(int)operator--operator--(int)	inkrementiert oder dekrementiert die Tick-Anzahl (public member function)
operator+=operator-=operator*=operator/=operator%=	implementiert zusammengesetzte Zuweisung zwischen zwei durations (public member function)

Non-member functions

operator+operator-operator*operator/operator% (C++11)	implementiert arithmetische Operationen mit Dauern als Argumente (Funktionstemplate)
operator==operator!=operator<operator<=operator>operator>=operator<=> (C++11)(C++11)(entfernt in C++20)(C++11)(C++11)(C++11)(C++11)(C++20)	vergleicht zwei Dauern (Funktionstemplate)
duration_cast (C++11)	konvertiert eine Dauer in eine andere mit einem anderen Tick-Intervall (Funktionstemplate)
floor(std::chrono::duration) (C++17)	konvertiert eine Dauer in eine andere und rundet ab (Funktionstemplate)
ceil(std::chrono::duration) (C++17)	konvertiert eine Dauer in eine andere und rundet auf (Funktionstemplate)
round(std::chrono::duration) (C++17)	konvertiert eine Dauer in eine andere, rundet auf die nächste, bei Gleichstand zu geraden Zahlen (Funktionstemplate)
abs(std::chrono::duration) (C++17)	ermittelt den Absolutwert der duration (function template)
operator<< (C++20)	führt die Stream-Ausgabe auf einer duration durch (function template)
from_stream (C++20)	parst eine duration aus einem Stream gemäß dem angegebenen Format (function template)

Hilfstypen

Ein Typ /* intXX */, der in der folgenden Tabelle verwendet wird, 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 duration-Typen bis einschließlich 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 ist gleich 365,2425 days (die durchschnittliche Länge eines gregorianischen Jahres). months ist gleich 30,436875 days (genau 1/12 von years).

(seit C++20)

Helper classes

std::common_type<std::chrono::duration> (C++11)	spezialisiert den std::common_type-Trait (Klassentemplate-Spezialisierung)
treat_as_floating_point (C++11)	zeigt an, dass eine duration in eine duration mit anderer Tick-Periode konvertierbar ist (class template)
duration_values (C++11)	erstellt Null-, Min- und Max-Werte eines Tick-Zählers gegebenen Typs (class template)
std::formatter<std::chrono::duration> (C++20)	Formatierungsunterstützung für duration (Klassentemplate-Spezialisierung)
std::hash<std::chrono::duration> (C++26)	Hash-Unterstützung für std::chrono::duration (Klassentemplate-Spezialisierung)

Helper specializations

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 zum Drucken eines chrono::duration-Objekts, wenn der Template-Parameter Rep dies zulässt.

Literale

Definiert im Inline-Namespace std::literals::chrono_literals
operator""h (C++14)	ein std::chrono::duration Literal, das Stunden repräsentiert (Funktion)
operator""min (C++14)	ein std::chrono::duration Literal, das Minuten repräsentiert (Funktion)
operator""s (C++14)	ein std::chrono::duration Literal, das Sekunden repräsentiert (Funktion)
operator""ms (C++14)	ein std::chrono::duration Literal, das Millisekunden repräsentiert (Funktion)
operator""us (C++14)	ein std::chrono::duration Literal, das Mikrosekunden repräsentiert (Funktion)
operator""ns (C++14)	ein std::chrono::duration Literal, das Nanosekunden repräsentiert (Funktion)

Hinweis: Die Suffixe d und y beziehen sich nicht auf days und years, sondern auf day bzw. year.

(seit C++20)

Anmerkungen

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 Zeit-Typen

Beispiel

Dieses Beispiel zeigt, wie mehrere benutzerdefinierte duration-Typen definiert und zwischen Typen konvertiert werden.

Führen Sie diesen Code aus

#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";
}

Ausgabe

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