Namespaces
Variants

operator+,-,*,/,% (std::chrono::duration)

From cppreference.net
C++
Date and time library
std::chrono::duration
Member functions
Non-member functions
operator+ operator- operator* operator/ operator%
(until C++20) (C++20)
(C++20)
Helper classes
template < class Rep1, class Period1, class Rep2, class Period2 >

typename std:: common_type < duration < Rep1,Period1 > , duration < Rep2,Period2 >> :: type
constexpr operator + ( const duration < Rep1,Period1 > & lhs,

const duration < Rep2,Period2 > & rhs ) ;
(1) (desde C++11)
template < class Rep1, class Period1, class Rep2, class Period2 >

typename std:: common_type < duration < Rep1,Period1 > , duration < Rep2,Period2 >> :: type
constexpr operator - ( const duration < Rep1,Period1 > & lhs,

const duration < Rep2,Period2 > & rhs ) ;
(2) (desde C++11)
template < class Rep1, class Period, class Rep2 >

duration < typename std:: common_type < Rep1,Rep2 > :: type , Period >
constexpr operator * ( const duration < Rep1,Period > & d,

const Rep2 & s ) ;
(3) (desde C++11)
template < class Rep1, class Rep2, class Period >

duration < typename std:: common_type < Rep1,Rep2 > :: type , Period >
constexpr operator * ( const Rep1 & s,

const duration < Rep2,Period > & d ) ;
(4) (desde C++11)
template < class Rep1, class Period, class Rep2 >

duration < typename std:: common_type < Rep1,Rep2 > :: type , Period >
constexpr operator / ( const duration < Rep1,Period > & d,

const Rep2 & s ) ;
(5) (desde C++11)
template < class Rep1, class Period1, class Rep2, class Period2 >

typename std:: common_type < Rep1,Rep2 > :: type
constexpr operator / ( const duration < Rep1,Period1 > & lhs,

const duration < Rep2,Period2 > & rhs ) ;
(6) (desde C++11)
template < class Rep1, class Period, class Rep2 >

duration < typename std:: common_type < Rep1,Rep2 > :: type , Period >
constexpr operator % ( const duration < Rep1, Period > & d,

const Rep2 & s ) ;
(7) (desde C++11)
template < class Rep1, class Period1, class Rep2, class Period2 >

typename std:: common_type < duration < Rep1,Period1 > , duration < Rep2,Period2 >> :: type
constexpr operator % ( const duration < Rep1,Period1 > & lhs,

const duration < Rep2,Period2 > & rhs ) ;
(8) (desde C++11)

Realiza operaciones aritméticas básicas entre dos duraciones o entre una duración y un recuento de ticks.

1) Convierte las dos duraciones a su tipo común y crea una duración cuyo recuento de tics es la suma de los recuentos de tics después de la conversión.
2) Convierte las dos duraciones a su tipo común y crea una duración cuyo conteo de ticks es el rhs número de ticks restado del lhs número de ticks después de la conversión.
3,4) Convierte la duración d a una cuyo rep es el tipo común entre Rep1 y Rep2 , y multiplica el número de ticks después de la conversión por s . Estas sobrecargas participan en la resolución de sobrecarga solo si s es convertible a typename std:: common_type < Rep1, Rep2 > :: type .
5) Convierte la duración d a una cuyo rep es el tipo común entre Rep1 y Rep2 , y divide el número de ticks después de la conversión por s . Esta sobrecarga participa en la resolución de sobrecarga solo si s es convertible a typename std:: common_type < Rep1, Rep2 > :: type y Rep2 no es una especialización de duration .
6) Convierte las dos duraciones a su tipo común y divide el conteo de ticks de lhs después de la conversión por el conteo de ticks de rhs después de la conversión. Nótese que el valor de retorno de este operador no es una duración.
7) Convierte la duración d a una cuyo rep es el tipo común entre Rep1 y Rep2 , y crea una duración cuyo conteo de ticks es el resto de la división del conteo de ticks, después de la conversión, por s . Esta sobrecarga participa en la resolución de sobrecarga solo si s es convertible a typename std:: common_type < Rep1, Rep2 > :: type y Rep2 no es una especialización de duration .
8) Convierte las dos duraciones a su tipo común y crea una duración cuyo conteo de ticks es el resto del conteo de ticks después de la conversión.

Contenidos

Parámetros

lhs - duración en el lado izquierdo del operador
rhs - duración en el lado derecho del operador
d - el argumento de duración para operadores de argumentos mixtos
s - argumento no-duración para operadores de argumentos mixtos

Valor de retorno

Suponiendo que CD es el tipo de retorno de la función y CD < A, B > = std:: common_type < A, B > :: type , entonces:

1) CD ( CD ( lhs ) . count ( ) + CD ( rhs ) . count ( ) )
2) CD ( CD ( lhs ) . count ( ) - CD ( rhs ) . count ( ) )
3,4) CD ( CD ( d ) . count ( ) * s )
5) CD ( CD ( d ) . count ( ) / s )
6) CD ( lhs ) . count ( ) / CD ( rhs ) . count ( ) (el tipo de retorno de este operador no es una duración)
7) CD ( CD ( d ) . count ( ) % s )
8) CD ( CD ( lhs ) . count ( ) % CD ( rhs ) . count ( ) )

Ejemplo

Ejecutar este código 
#include <chrono>
#include <iostream>
int main()
{
    // Aritmética simple:
    std::chrono::seconds s = std::chrono::hours(1)
                           + 2 * std::chrono::minutes(10)
                           + std::chrono::seconds(70) / 10;
    std::cout << "1 hora + 2*10 min + 70/10 seg = " << s << " (segundos)\n";
    using namespace std::chrono_literals;
    // Diferencia entre dividir una duración por un número
    // y dividir una duración por otra duración:
    std::cout << "Dividir eso por 2 minutos da "
              << s / 2min << '\n'
              << "Dividir eso por 2 da "
              << (s / 2).count() << " segundos\n";
    // El operador de resto es útil para determinar dónde
    // en un marco temporal se encuentra esta duración particular, p.ej. para
    // descomponerlo en horas, minutos y segundos:
    std::cout << s << " (segundos) = "
              << std::chrono::duration_cast<std::chrono::hours>(
                 s) << " (hora) + "
              << std::chrono::duration_cast<std::chrono::minutes>(
                 s % 1h) << " (minutos) + "
              << std::chrono::duration_cast<std::chrono::seconds>(
                 s % 1min) << " (segundos)\n";
    constexpr auto sun_earth_distance{150'000'000ULL}; // km
    constexpr auto speed_of_light{300000ULL}; // km/seg
    std::chrono::seconds t(sun_earth_distance / speed_of_light); // seg
    std::cout << "Un fotón viaja desde el Sol a la Tierra en "
              << t / 1min << " minutos " << t % 1min << " (segundos)\n";
}

Salida: 

1 hora + 2*10 min + 70/10 seg = 4807s (segundos)
Dividir eso por 2 minutos da 40
Dividir eso por 2 da 2403 segundos
4807s (segundos) = 1h (hora) + 20min (minutos) + 7s (segundos)
Un fotón viaja desde el Sol a la Tierra en 8 minutos 20s (segundos)

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 3050 C++11 restricción de convertibilidad usaba xvalue no constante usar lvalues constantes en su lugar