std::chrono::duration

 

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

 

Biblioteca de servicios

Apoyo del lenguaje Apoyo de tipos (tipos básicos, RTTI) Biblioteca de macros de prueba de característica (C++20) Servicios del programa Apoyo de corrutinas (C++20) Funciones variádicas is_constant_evaluated (C++20) is_within_lifetime (C++26) initializer_list (C++11) source_location (C++20) Comparación de tres vías three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Servicios generales Objetos función Manipulación de bits (C++20) bitset hash (C++11) Operadores relacionales (en desuso en C++20) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Funciones de comparación de enteros cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Intercambio y operaciones de tipos swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Tipos vocabulario comunes pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

Utilerías de fecha y hora

Punto de tiempo
time_point (C++11)	clock_time_conversion (C++20)	clock_cast (C++20)
Duración
duration (C++11)
Relojes
system_clock (C++11) steady_clock (C++11) high_resolution_clock (C++11)	is_clock (C++20) utc_clock (C++20) tai_clock (C++20)	gps_clock (C++20) file_clock (C++20) local_t (C++20)
Hora del día
is_amis_pm (C++20)(C++20)	make12make24 (C++20)(C++20)	hh_mm_ss (C++20)
Calendario
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)
Zona horaria
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)
E/S de chrono
parse (C++20)
Fecha y hora estilo C

 

std::chrono::duration

Funciones miembro
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%=
Funciones no miembro
operator+operator-operator*operator/operator% operator==operator!=operator<operator<=operator>operator>=operator<=> (hasta 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)
Clases auxiliares
common_type treat_as_floating_point	duration_values formatter<std::chrono::duration> (C++20)

 

<tbody> </tbody>

Definido en el archivo de encabezado <chrono>
template< class Rep, class Period = std::ratio<1> > class duration;		(desde C++11)

See More

La plantilla de clase std::chrono::duration representa un intervalo de tiempo.

Consiste en una cuenta de tics de tipo Rep y un período de tic, donde el período de tic es una fracción racional en tiempo de compilación que representa el tiempo en segundos de un tic al siguiente.

Los únicos datos almacenados en duration es una cuenta de tics de tipo Rep. Si {{tt|Rep} } es de punto flotante, entonces duration puede representar fracciones de tics. Period se incluye como parte del tipo de duración y solo se usa al realizar conversiones entre diferentes duraciones.

Tipos miembro

Tipo miembro	Definición
rep	Rep, un tipo aritmético que representa el número de tics.
period	Period (hasta C++17)typename Period::type (desde C++17), un std::ratio que representa el período de tic (es decir, el número de fracciones de segundo por tic)

Funciones miembro

(constructor)	Construye una nueva duración. (función miembro pública)
operator=	Asigna el contenido. (función miembro pública)
count	Devuelve la cuenta de tics. (función miembro pública)
zero [estático]	Devuelve el valor de duración especial zero. (función miembro estática pública)
min [estático]	Devuelve el valor de duración especial min. (función miembro estática pública)
max [estático]	Devuelve el valor de duración especial max. (función miembro estática pública)
operator+operator-	Implementa + unario y - unario. (función miembro pública)
operator++operator++(int)operator--operator--(int)	Incrementa o decrementa la cuenta de tics. (función miembro pública)
operator+=operator-=operator*=operator/=operator%=	Implementa asignación compuesta entre dos duraciones. (función miembro pública)

Funciones no miembro

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)
operator<< (C++20)	Emite salida en un flujo sobre un objeto de tipo duration. (plantilla de función)
from_stream (C++20)	Analiza un objeto de tipo duración a partir de un flujo de acuerdo con el formato proporcionado. (plantilla de función)

Tipos auxiliares

Tipo	Definición
std::chrono::nanoseconds	duration</*tipo entero con signo de al menos 64 bits*/, std::nano>
std::chrono::microseconds	duration</*tipo entero con signo de al menos 55 bits*/, std::micro>
std::chrono::milliseconds	duration</*tipo entero con signo de al menos 45 bits*/, std::milli>
std::chrono::seconds	duration</*tipo entero con signo de al menos 35 bits*/>
std::chrono::minutes	duration</*tipo entero con signo de al menos 29 bits*/, std::ratio<60>>
std::chrono::hours	duration</*tipo entero con signo de al menos 23 bits*/, std::ratio<3600>>
std::chrono::days (desde C++20)	duration</*tipo entero con signo de al menos 25 bits*/, std::ratio<86400>>
std::chrono::weeks (desde C++20)	duration</*tipo entero con signo de al menos 22 bits*/, std::ratio<604800>>
std::chrono::months (desde C++20)	duration</*tipo entero con signo de al menos 20 bits*/, std::ratio<2629746>>
std::chrono::years (desde C++20)	duration</*tipo entero con signo de al menos 17 bits*/, std::ratio<31556952>>

Nota: cada uno de los tipos de duración predefinidos hasta hours cubre un rango de al menos ±292 años.

Cada uno de los tipos de duración predefinidos days, weeks, months y years cubre un rango de al menos ±40000 años. years es igual a 365.2425 days (la duración media de un año gregoriano). months es igual a 30.436875 days (exactamente 1/12 de years).

(desde C++20)

Clases auxiliares

std::common_type<std::chrono::duration>	Especializa el rasgo std::common_type. (especialización de plantilla de clase)
treat_as_floating_point (C++11)	Indica que una duración es convertible a una duración con un período de tic diferente. (plantilla de clase)
duration_values (C++11)	Construye valores cero, mínimo y máximo de una cuenta de tics de un tipo dado. (plantilla de clase)
std::formatter<std::chrono::duration> (C++20)	Especialización de std::formatter que da formato a un objeto de tipo duration según el formato proporcionado. (especialización de plantilla de clase)

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)

Nota: los sufijos de literal d e y no se refieren a days y years sino a day y year, respectivamente.

(desde C++20)

Macro de Prueba de característica
__cpp_lib_chrono_udls

(para literales definidos por el usuario).

Notas

El intervalo de tiempo real (en segundos) que tiene un objeto de duración d es aproximadamente igual a d.count() * D::period::num / D::period ::den, donde D es de tipo chrono::duration<> y d es un objeto de ese tipo.

Ejemplo

Este ejemplo muestra cómo definir varios tipos de duración personalizados y convertir entre tipos:

Ejecuta este código

#include <iostream>
#include <chrono>
using namespace std::chrono_literals;

template<typename T1, typename T2>
using mul = std::ratio_multiply<T1, T2>;

int main()
{
    using sacudidas = std::chrono::duration<int, mul<std::deca, std::nano>>;
    using momentitos = std::chrono::duration<int, std::centi>;
    using microquincenas = std::chrono::duration<float,
        mul<mul<std::ratio<2>, std::chrono::weeks::period>, std::micro>>;
    using nanosiglos = 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 segundo es:\n";

    // conversión de escala entera sin pérdida de precisión: sin conversión
    std::cout << std::chrono::microseconds(1s).count() << " microsegundos\n"
              << sacudidas(1s).count() << " sacudidas\n"
              << momentitos(1s).count() << " momentitos\n";

    // conversión de escala entera con pérdida de precisión: requiere conversión
    std::cout << std::chrono::duration_cast<std::chrono::minutes>(1s).count()
              << " minutos\n";

    // conversión de escala de punto flotante: sin conversión
    std::cout << microquincenas(1s).count() << " microquincenas\n"
              << nanosiglos(1s).count() << " nanosiglos\n"
              << fps_24(1s).count() << " fotogramas a 24fps\n";
}

Salida:

1 segundo es:
1000000 microsegundos
100000000 sacudidas
100 momentitos
0 minutos
0.82672 microquincenas
0.316887 nanosiglos
24 fotogramas a 24fps