operator+,-,*,/,%(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) Macros de prueba de característica de la biblioteca (C++20) Servicios de programa Funciones variádicas initializer_list (C++11) is_constant_evaluated (C++20) is_within_lifetime (C++26) source_location (C++20) Apoyo de corrutinas (C++20) Apoyo de contratos (C++26) Comparación de tres vías (C++20) 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)

 

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

Realiza operaciones aritméticas básicas entre dos duraciones o entre una duración y una cuenta de tics.

1) Convierte las dos duraciones a su tipo común y crea una duración cuya cuenta de tics es la suma de las cuentas de tics después de la conversión.

2) Convierte las dos duraciones a su tipo común y crea una duración cuya cuenta de tics es número rhs de tics restado del número lhs de tics después de la conversión.

3-4) Convierte la duración d a una cuya rep es el tipo común entre Rep1 y Rep2, y multiplica el número de tics después de la conversión por s. Estas sobrecargas solo participan en la resolución de sobrecargas si s es convertible a typename std::common_type<Rep1, Rep2>::type.

5) Convierte la duración d a una cuya rep es el tipo común entre Rep1 y Rep2, y divide el número de tics después de la conversión por s. Esta sobrecarga solo participa en la resolución de sobrecargas 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 la cuenta de tics de lhs después de la conversión por la cuenta de tics de rhs después de la conversión. Ten en cuenta que el valor de retorno de este operador no es una duración.

7) Convierte la duración d a una cuya rep es el tipo común entre Rep1 y Rep2, y crea una duración cuya cuenta de tics es el resto de la división de la cuenta de tics, después de la conversión, por s. Esta sobrecarga solo participa en la resolución de sobrecargas 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 cuya cuenta de tics es el resto de las cuents de tics después de la conversión.

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	-	El argumento que no es duración para operadores de argumentos mixtos.

Valor de retorno

Suponiendo que CD es el tipo de retorno de función y CR<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

Ejecuta 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 sec = " << s.count() << " segundos\n";

    // diferencia entre dividir una duracion por un número
    // y dividir una duración por otra duración
    std::cout << "Dividir eso por 2 minutos da "
              << s / std::chrono::minutes(2) << '\n';
    std::cout << "Dividir eso por 2 da "
              << (s / 2).count() << " segundos\n";

   // el operador de resto es útil para determinar en qué parte de un período
   // de tiempo se encuentra esta duración particular, p. para dividirlo en horas,
   // minutos y segundos:
   std::cout << s.count() << " segundos es "
             << std::chrono::duration_cast<std::chrono::hours>(
                    s
                ).count() << " hora(s), "
             << std::chrono::duration_cast<std::chrono::minutes>(
                    s % std::chrono::hours(1)
                ).count() << " minutos, "
             << std::chrono::duration_cast<std::chrono::seconds>(
                    s % std::chrono::minutes(1)
                ).count() << " segundos\n";
}

Salida:

1 hora + 2*10 min + 70/10 sec = 4807 segundos
Dividir eso por 2 minutos da 40
Dividir eso por 2 da 2403 segundos
4807 segundos es 1 hora(s), 20 minutos, 7 segundos

Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

ID	Aplicado a	Comportamiento según lo publicado	Comportamiento correcto
LWG 3050	C++11	La restricción de convertibilidad usaba un x-valor no const.	Usa l-valores const en su lugar.