Namespaces
Variants

std::chrono:: duration

From cppreference.net
C++
Date and time library
std::chrono::duration
Member functions
Non-member functions
Helper classes
Definido en el encabezado <chrono>
template <

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

> class duration ;
(desde C++11)

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

Consiste en un conteo de ticks de tipo Rep y un período de tick, donde el período de tick es una fracción racional fraction en tiempo de compilación que representa el tiempo en segundos de un tick al siguiente.

Los únicos datos almacenados en un duration es un recuento de ticks de tipo Rep . Si Rep es de punto flotante, entonces el duration puede representar fracciones de ticks. Period se incluye como parte del tipo de duración, y solo se utiliza al convertir entre diferentes duraciones.

Contenidos

Tipos de miembros

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

Funciones miembro

construye un nuevo duration
(función miembro pública)
asigna los contenidos
(función miembro pública)
devuelve el conteo de ticks
(función miembro pública)
[static]
devuelve el valor especial duration zero
(función miembro estática pública)
[static]
devuelve el valor especial duration min
(función miembro estática pública)
[static]
devuelve el valor especial duration max
(función miembro estática pública)
implementa + unario y - unario
(función miembro pública)
incrementa o decrementa el conteo de ticks
(función miembro pública)
implementa asignación compuesta entre dos durations
(función miembro pública)

Funciones no miembro

(C++11)
implementa operaciones aritméticas con duraciones como argumentos
(plantilla de función)
(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)
(C++11)
convierte una duración a otra, con un intervalo de ticks diferente
(plantilla de función)
(C++17)
convierte una duración a otra, redondeando hacia abajo
(plantilla de función)
(C++17)
convierte una duración a otra, redondeando hacia arriba
(plantilla de función)
(C++17)
convierte una duración a otra, redondeando al más cercano, empates al par
(plantilla de función)
(C++17)
obtiene el valor absoluto de la duración
(plantilla de función)
(C++20)
realiza salida por flujo en una duration
(plantilla de función)
(C++20)
analiza una duration desde un flujo según el formato proporcionado
(plantilla de función)

Tipos auxiliares

Un tipo /* intXX */ utilizado en la siguiente tabla significa un tipo entero con signo de al menos XX bits.

Tipo Definición
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 (desde C++20) std :: chrono :: duration < /* int25 */ , std:: ratio < 86400 >>
std::chrono::weeks (desde C++20) std :: chrono :: duration < /* int22 */ , std:: ratio < 604800 >>
std::chrono::months (desde C++20) std :: chrono :: duration < /* int20 */ , std:: ratio < 2629746 >>
std::chrono::years (desde C++20) std :: chrono :: duration < /* int17 */ , 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 longitud promedio de un año gregoriano). months es igual a 30.436875 days (exactamente 1/12 de years ).

(since C++20)

Clases auxiliares

(C++11)
especializa el rasgo std::common_type
(especialización de plantilla de clase)
(C++11)
indica que una duración es convertible a duración con diferente período de tic
(plantilla de clase)
(C++11)
construye los valores cero, mínimo y máximo de un conteo de tics de un tipo dado
(plantilla de clase)
(C++20)
soporte de formato para duration
(especialización de plantilla de clase)
(C++26)
soporte de hash para std::chrono::duration
(especialización de plantilla de clase)

Especializaciones auxiliares

template < class Rep, class Period >

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

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

Esta especialización de std::enable_nonlocking_formatter_optimization permite una implementación eficiente de std::print y std::println para imprimir un objeto chrono::duration cuando el parámetro de plantilla Rep lo permite.

Literales

Definido en el espacio de nombres en línea std::literals::chrono_literals
(C++14)
un literal de std::chrono::duration que representa horas
(función)
(C++14)
un literal de std::chrono::duration que representa minutos
(función)
(C++14)
un literal de std::chrono::duration que representa segundos
(función)
(C++14)
un literal de std::chrono::duration que representa milisegundos
(función)
(C++14)
un literal de std::chrono::duration que representa microsegundos
(función)
(C++14)
un literal de std::chrono::duration que representa nanosegundos
(función)

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

(desde C++20)

Notas

El intervalo de tiempo real (en segundos) que contiene 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 dicho tipo.

Macro de prueba de características Valor Estándar Característica
__cpp_lib_chrono_udls 201304L (C++14) Literales definidos por el usuario para tipos de tiempo

Ejemplo

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

Ejecutar este código 
#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";
}

Salida: 

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