Archivo de encabezado de la biblioteca estándar <chrono>

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos(C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación(C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos(C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos(C++17)

Biblioteca de apoyo de concurrencia(C++11)

Biblioteca de apoyo de ejecución(C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Archivos de encabezado de la biblioteca estándar

Apoyo del lenguaje <cfloat> <climits> <compare>(C++20) <coroutine>(C++20) <csetjmp> <csignal> <cstdarg> <cstddef> <cstdint>(C++11) <cstdlib> <exception> <initializer_list>(C++11)    <limits> <new> <source_location>(C++20) <stdfloat>(C++23) <typeinfo> <version>(C++20) Conceptos <concepts>(C++20) Diagnósticos <cassert> <cerrno> <debugging>(C++26) <stacktrace>(C++23) <stdexcept> <system_error>(C++11) Gestión de memoria <memory> <memory_resource>(C++17) <scoped_allocator>(C++11) Metaprogramación <type_traits>(C++11) <ratio>(C++11)

Servicios generales <any>(C++17) <bitset> <bit>(C++20) <charconv>(C++17) <expected>(C++23) <format>(C++20) <functional> <optional>(C++17) <tuple>(C++11) <typeindex>(C++11) <utility> <variant>(C++17) Contenedores <array>(C++11) <deque> <flat_map>(C++23) <flat_set>(C++23) <forward_list>(C++11) <inplace_vector>(C++26)    <list> <map> <mdspan>(C++23) <queue> <set> <span>(C++20) <stack> <unordered_map>(C++11) <unordered_set>(C++11) <vector> Iteradores <iterator> Rangos <generator>(C++23) <ranges>(C++20)

Algoritmos <algorithm> <numeric> Cadenas <cctype> <cstring> <cuchar>(C++11) <cwchar> <cwctype> <string_view>(C++17) <string> Procesamiento de texto <clocale> <codecvt>(C++11/17/26*) <locale> <regex>(C++11) <text_encoding>(C++26)    Numéricos <cfenv>(C++11) <cmath> <complex> <linalg>(C++26) <numbers>(C++20) <random>(C++11) <simd>(C++26) <valarray> Tiempo <chrono>(C++11) <ctime> Compatibilidad con C <ccomplex>(C++11/17/20*) <ciso646>(hasta C++20) <cstdalign>(C++11/17/20*) <cstdbool>(C++11/17/20*) <ctgmath>(C++11/17/20*)

Entrada/Salida <cinttypes>(C++11) <cstdio> <filesystem>(C++17) <fstream> <iomanip> <iosfwd> <iostream> <ios> <istream> <ostream> <print>(C++23) <spanstream>(C++23) <sstream> <streambuf> <strstream>(C++98/26*) <syncstream>(C++20) Apoyo para concurrencia <atomic>(C++11) <barrier>(C++20) <condition_variable>(C++11) <future>(C++11) <hazard_pointer>(C++26) <latch>(C++20) <mutex>(C++11) <rcu>(C++26) <semaphore>(C++20) <shared_mutex>(C++14) <stdatomic.h>(C++23) <stop_token>(C++20) <thread>(C++11) Apoyo de ejecución <execution>(C++17)

 

Este archivo de encabezado es parte de la biblioteca de fecha y hora.

Clases

Definido en el espacio de nombres std::chrono
duration (C++11)	Un intervalo de tiempo. (plantilla de clase)
system_clock (C++11)	Tiempo de pared a partir del reloj de tiempo real a lo largo del sistema. (clase)
steady_clock (C++11)	Reloj monotónico que nunca será ajustado. (clase)
high_resolution_clock (C++11)	El reloj con mayor precisión disponible en el sistema. (clase)
time_point (C++11)	Un punto de tiempo. (plantilla de clase)
treat_as_floating_point	Indica que una duración es convertible a una duración con un período de tic distinto. (plantilla de clase)
duration_values	Construye valores cero, mínimo y máximo de una cuenta de tics del tipo dado. (plantilla de clase)
time_zone (C++20)	Representa una zona horaria. (clase)
nonexistent_local_time (C++20)	Excepción lanzada para reportar que una hora local no existe. (clase)
ambiguous_local_time (C++20)	Excepción lanzada para informar que una hora local es ambigua. (clase)
Definiciones de tipo convenientes
Definido en el espacio de nombres std::chrono
std::chrono::nanoseconds	Tipo de duración con período std::nano
std::chrono::microseconds	Tipo de duración con período std::micro
std::chrono::milliseconds	Tipo de duración con período std::milli
std::chrono::seconds	Tipo de duración con período std::ratio<1>
std::chrono::minutes	Tipo de duración con período std::ratio<60>
std::chrono::hours	Tipo de duración con período std::ratio<3600>
std::chrono::days	Tipo de duración con período std::ratio<86400>
std::chrono::weeks	Tipo de duración con período std::ratio<604800>
std::chrono::months	Tipo de duración con período std::ratio<2629746>
std::chrono::years	Tipo de duración con período std::ratio<31556952>
Especializaciones
Definido en el espacio de nombres std
std::common_type<std::chrono::duration>	Especializa el rasgo std::common_type. (especialización de plantilla de clase)
std::common_type<std::chrono::time_point>	Especializa el rasgo std::common_type. (especialización de plantilla de clase)

Funciones

Duración
Definido en el espacio de nombres std::chrono
operator+operator-operator*operator/operator%	Implementa operaciones aritméticas con duraciones como argumentos. (plantilla de función)
operator==operator!=operator<operator<=operator>operator>=operator<=> (C++11)(C++11)(eliminado en C++20)(C++11)(C++11)(C++11)(C++11)(C++20)	Compara dos duraciones. (plantilla de función)
duration_cast (C++11)	Convierte una duración a otra, con un intervalo de tic diferente. (plantilla de función)
floor(std::chrono::duration) (C++17)	Convierte una duración a otra, redondeando hacia abajo. (plantilla de función)
ceil(std::chrono::duration) (C++17)	Convierte una duración a otra, redondeando hacia arriba. (plantilla de función)
round(std::chrono::duration) (C++17)	Convierte una duración a otra, redondeando al más cercano, se empata con par. (plantilla de función)
abs(std::chrono::duration) (C++17)	Obtiene el valor absoluto de la duración. (plantilla de función)
Punto de tiempo
Definido en el espacio de nombres std::chrono
operator+operator-	Realiza operaciones de suma y resta que involucran un punto de tiempo. (plantilla de función)
operator==operator!=operator<operator<=operator>operator>=	Compara dos puntos de tiempo. (plantilla de función)
time_point_cast	Convierte un punto de tiempo a otro punto de tiempo en el mismo reloj, con una duración diferente. (plantilla de función)
floor(std::chrono::time_point) (C++17)	Convierte un punto de tiempo a otro, redondeando hacia abajo (piso). (plantilla de función)
ceil(std::chrono::time_point) (C++17)	Convierte un punto de tiempo a otro, redondeando hacia arriba (techo). (plantilla de función)
round(std::chrono::time_point) (C++17)	Convierte un punto de tiempo a otro, redondeando al más cercano, se empata con par. (plantilla de función)
Literales
Definido en el espacio de nombres std::literals::chrono_literals
operator""h (C++14)	Un literal std::chrono::duration que representa horas. (función)
operator""min (C++14)	Un literal std::chrono::duration que representa minutos. (función)
operator""s (C++14)	Un literal std::chrono::duration que representa segundos. (función)
operator""ms (C++14)	Un literal std::chrono::duration que representa milisegundos. (función)
operator""us (C++14)	Un literal std::chrono::duration que representa microsegundos. (función)
operator""ns (C++14)	Un literal std::chrono::duration que representa nanosegundos. (función)
operator""d (C++20)	Un literal std::chrono::day que representa un día de un mes. (función)
operator""y (C++20)	Un literal std::chrono::year que representa un año en particular. (función)

Sinopsis

namespace std {namespace chrono {// plantilla de clase durationtemplate<class Rep, class Period = ratio<1>>class duration;// plantilla de clase time_pointtemplate<class Clock, class Duration =typename Clock::duration>class time_point;}// especializaciones de common_typetemplate<class Rep1, class Period1, class Rep2, class Period2>struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2>>;template<class Clock, class Duration1, class Duration2>struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2>>;namespace chrono {// rasgos de personalizacióntemplate<class Rep>struct treat_as_floating_point;template<class Rep>struct duration_values;template<class Rep>constexprbool treat_as_floating_point_v = treat_as_floating_point<Rep>::value;// aritmética de durationtemplate<class Rep1, class Period1, class Rep2, class Period2> common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>constexpr operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);template<class Rep1, class Period1, class Rep2, class Period2> common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>constexpr operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);template<class Rep1, class Period, class Rep2> duration<common_type_t<Rep1, Rep2>, Period>constexpr operator*(const duration<Rep1, Period>& d, const Rep2& s);template<class Rep1, class Rep2, class Period> duration<common_type_t<Rep1, Rep2>, Period>constexpr operator*(const Rep1& s, const duration<Rep2, Period>& d);template<class Rep1, class Period, class Rep2> duration<common_type_t<Rep1, Rep2>, Period>constexpr operator/(const duration<Rep1, Period>& d, const Rep2& s);template<class Rep1, class Period1, class Rep2, class Period2> common_type_t<Rep1, Rep2>constexpr operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);template<class Rep1, class Period, class Rep2> duration<common_type_t<Rep1, Rep2>, Period>constexpr operator%(const duration<Rep1, Period>& d, const Rep2& s);template<class Rep1, class Period1, class Rep2, class Period2> common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>constexpr operator%(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);// comparaciones de durationtemplate<class Rep1, class Period1, class Rep2, class Period2>constexprbool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);template<class Rep1, class Period1, class Rep2, class Period2>constexprbool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);template<class Rep1, class Period1, class Rep2, class Period2>constexprbool operator<(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);template<class Rep1, class Period1, class Rep2, class Period2>constexprbool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);template<class Rep1, class Period1, class Rep2, class Period2>constexprbool operator>(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);template<class Rep1, class Period1, class Rep2, class Period2>constexprbool operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);// conversiones duration_casttemplate<class ToDuration, class Rep, class Period>constexpr ToDuration duration_cast(const duration<Rep, Period>& d);template<class ToDuration, class Rep, class Period>constexpr ToDuration floor(const duration<Rep, Period>& d);template<class ToDuration, class Rep, class Period>constexpr ToDuration ceil(const duration<Rep, Period>& d);template<class ToDuration, class Rep, class Period>constexpr ToDuration round(const duration<Rep, Period>& d);// definiciones de tipo convenientesusing nanoseconds = duration</*entero con signo de al menos 64 bits*/ , nano>;using microseconds = duration</*entero con signo de al menos 55 bits*/ , micro>;using milliseconds = duration</*entero con signo de al menos 45 bits*/ , milli>;using seconds = duration</*entero con signo de al menos 35 bits*/>;using minutes = duration</*entero con signo de al menos 29 bits*/ , ratio<60>>;using hours = duration</*entero con signo de al menos 23 bits*/ , ratio<3600>>;// aritmética de time_pointtemplate<class Clock, class Duration1, class Rep2, class Period2>constexpr time_point<Clock, common_type_t<Duration1, duration<Rep2, Period2>>> operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);template<class Rep1, class Period1, class Clock, class Duration2>constexpr time_point<Clock, common_type_t<duration<Rep1, Period1>, Duration2>> operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);template<class Clock, class Duration1, class Rep2, class Period2>constexpr time_point<Clock, common_type_t<Duration1, duration<Rep2, Period2>>> operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);template<class Clock, class Duration1, class Duration2>constexpr common_type_t<Duration1, Duration2> operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);// comparaciones de time_pointtemplate<class Clock, class Duration1, class Duration2>constexprbool operator==(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);template<class Clock, class Duration1, class Duration2>constexprbool operator!=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);template<class Clock, class Duration1, class Duration2>constexprbool operator<(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);template<class Clock, class Duration1, class Duration2>constexprbool operator<=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);template<class Clock, class Duration1, class Duration2>constexprbool operator>(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);template<class Clock, class Duration1, class Duration2>constexprbool operator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);// time_point_casttemplate<class ToDuration, class Clock, class Duration>constexpr time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);template<class ToDuration, class Clock, class Duration>constexpr time_point<Clock, ToDuration> floor(const time_point<Clock, Duration>& tp);template<class ToDuration, class Clock, class Duration>constexpr time_point<Clock, ToDuration> ceil(const time_point<Clock, Duration>& tp);template<class ToDuration, class Clock, class Duration>constexpr time_point<Clock, ToDuration> round(const time_point<Clock, Duration>& tp);// algoritmos especializadostemplate<class Rep, class Period>constexpr duration<Rep, Period> abs(duration<Rep, Period> d);// relojesclass system_clock;class steady_clock;class high_resolution_clock;}inlinenamespace literals {inlinenamespace chrono_literals {// sufijos para los literales de durationconstexpr chrono::hours operator "" h(unsignedlonglong);constexpr chrono::duration</*no especificado*/, ratio<3600,1>> operator "" h(longdouble);constexpr chrono::minutes operator "" min(unsignedlonglong);constexpr chrono::duration</*no especificado*/, ratio<60,1>> operator "" min(longdouble);constexpr chrono::seconds operator "" s(unsignedlonglong);constexpr chrono::duration</*no especificado*/> operator "" s(longdouble);constexpr chrono::milliseconds operator "" ms(unsignedlonglong);constexpr chrono::duration</*no especificado*/, milli> operator "" ms(longdouble);constexpr chrono::microseconds operator "" us(unsignedlonglong);constexpr chrono::duration</*no especificado*/, micro> operator "" us(longdouble);constexpr chrono::nanoseconds operator "" ns(unsignedlonglong);constexpr chrono::duration</*no especificado*/, nano> operator "" ns(longdouble);constexpr chrono::day operator""d(unsignedlonglong d)noexcept;constexpr chrono::year operator""y(unsignedlonglong y)noexcept;}}namespace chrono {usingnamespace literals::chrono_literals;}

std::chrono::treat_as_floating_point

template<class Rep>struct treat_as_floating_point : is_floating_point<Rep>{};

std::chrono::duration_values

template<class Rep>struct duration_values {public:staticconstexpr Rep zero();staticconstexpr Rep min();staticconstexpr Rep max();};

std::chrono::duration

template<class Rep, class Period = ratio<1>>class duration {public:using rep = Rep;using period = Period;private: rep rep_;// solo exposiciónpublic:// construcción/copia/destrucciónconstexpr duration()=default;template<class Rep2>constexprexplicit duration(const Rep2& r);template<class Rep2, class Period2>constexpr duration(const duration<Rep2, Period2>& d); ~duration()=default; duration(const duration&)=default; duration& operator=(const duration&)=default;// observadorconstexpr rep count()const;// aritméticaconstexpr duration operator+()const;constexpr duration operator-()const;constexpr duration& operator++();constexpr duration operator++(int);constexpr duration& operator--();constexpr duration operator--(int);constexpr duration& operator+=(const duration& d);constexpr duration& operator-=(const duration& d);constexpr duration& operator*=(const rep& rhs);constexpr duration& operator/=(const rep& rhs);constexpr duration& operator%=(const rep& rhs);constexpr duration& operator%=(const duration& rhs);// valores especialesstaticconstexpr duration zero();staticconstexpr duration min();staticconstexpr duration max();};

std::chrono::time_point

template<class Clock, class Duration =typename Clock::duration>class time_point {public:using clock = Clock;using duration = Duration;using rep =typename duration::rep;using period =typename duration::period;private: duration d_;// solo exposiciónpublic:// construcciónconstexpr time_point();// has value epochconstexprexplicit time_point(const duration& d);// lo mismo que time_point() + dtemplate<class Duration2>constexpr time_point(const time_point<clock, Duration2>& t);// observadorconstexpr duration time_since_epoch()const;// aritméticaconstexpr time_point& operator+=(const duration& d);constexpr time_point& operator-=(const duration& d);// valores especialesstaticconstexpr time_point min();staticconstexpr time_point max();};

std::chrono::system_clock

class system_clock {public:using rep =/*véase descripción*/;using period = ratio</*no especificado*/, /*no especificado*/>;using duration = chrono::duration<rep, period>;using time_point = chrono::time_point<system_clock>;staticconstexprbool is_steady =/*no especificado*/;static time_point now()noexcept;// Relacionar con la API de Cstatic time_t to_time_t (const time_point& t)noexcept;static time_point from_time_t(time_t t)noexcept;};

std::chrono::steady_clock

class steady_clock {public:using rep =/*no especificado*/;using period = ratio</*no especificado*/, /*no especificado*/>;using duration = chrono::duration<rep, period>;using time_point = chrono::time_point</*no especificado*/, duration>;staticconstexprbool is_steady =true;static time_point now()noexcept;};

std::chrono::high_resolution_clock

class high_resolution_clock {public:using rep =/*no especificado*/;using period = ratio</*no especificado*/, /*no especificado*/>;using duration = chrono::duration<rep, period>;using time_point = chrono::time_point</*no especificado*/, duration>;staticconstexprbool is_steady =/*no especificado*/;static time_point now()noexcept;};