Espacios de nombres
Variantes
Acciones

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

De cppreference.com
< cpp‎ | chrono‎ | duration

 
 
Utilidades de la biblioteca
Escriba apoyo (basic types, RTTI, type traits)
Gestión de memoria dinámica
Gestión de errores
Programa de servicios públicos
Funciones variadic
Fecha y hora
Objetos Function
initializer_list(C++11)
bitset
hash(C++11)
Operadores relacionales
Original:
Relational operators
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
rel_ops::operator!=
rel_ops::operator>
rel_ops::operator<=
rel_ops::operator>=
Pares y tuplas
Original:
Pairs and tuples
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
pair
tuple(C++11)
piecewise_construct_t(C++11)
piecewise_construct(C++11)
Cambiar, hacia adelante y mover
Original:
Swap, forward and move
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
swap
forward(C++11)
move(C++11)
move_if_noexcept(C++11)
declval(C++11)
 
 
std::chrono::duration
Las funciones miembro
Original:
Member functions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
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%=
Terceros funciones
Original:
Non-member functions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
common_type
operator+
operator-
operator*
operator/
operator%
operator==
operator!=
operator<
operator<=
operator>
operator>=
duration_cast
Clases de ayuda
Original:
Helper classes
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
treat_as_floating_point
duration_values
 
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 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 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 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 un contador .
Original:
Performs basic arithmetic operations between two durations or between a duration and a tick count.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
1)
Convierte las dos duraciones de su tipo común y crea una duración cuyo recuento de garrapata es la suma de los recuentos de garrapatas después de la conversión .
Original:
Converts the two durations to their common type and creates a duration whose tick count is the sum of the tick counts after conversion.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
2)
Convierte las dos duraciones de su tipo común y crea una duración cuya garrapata número es el número de garrapatas rhs resta del número de garrapatas lhs después de la conversión .
Original:
Converts the two durations to their common type and creates a duration whose tick count is the rhs number of ticks subtracted from the lhs number of ticks after conversion.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
3-4)
Convierte el d duración a aquel cuya rep es el tipo común entre Rep1 y Rep2 y multiplica el número de garrapatas después de la conversión por s .
Original:
Converts the duration d to one whose rep is the common type between Rep1 and Rep2, and multiples the number of ticks after conversion by s.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
5)
Convierte el d duración a aquel cuya rep es el tipo común entre Rep1 y Rep2, y divide el número de garrapatas después de la conversión por s
Original:
Converts the duration d to one whose rep is the common type between Rep1 and Rep2, and divides the number of ticks after conversion by s
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
6)
Convierte los dos duraciones a su tipo común y divide el contador de lhs después de la conversión por el contador de rhs después de la conversión. Tenga en cuenta que el valor de retorno de este operador no es una duración .
Original:
Converts the two durations to their common type and divides the tick count of lhs after conversion by the tick count of rhs after conversion. Note that the return value of this operator is not a duration.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
7)
Convierte el d duración a uno cuya rep es el tipo común entre Rep1 y Rep2, y crea una duración cuyo recuento de garrapata es el resto de la división del contador, después de la conversión, por s .
Original:
Converts the duration d to one whose rep is the common type between Rep1 and Rep2, and creates a duration whose tick count is the remainder of the division of the tick count, after conversion, by s.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
8)
Convierte las dos duraciones de su tipo común y crea una duración cuyo recuento de garrapata es el resto de los recuentos de garrapatas después de la conversión .
Original:
Converts the two durations to their common type and creates a duration whose tick count is the remainder of the tick counts after conversion.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[editar] Parámetros

lhs -
duración en el lado izquierdo del operador
Original:
duration on the left-hand side of the operator
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
rhs -
duración en el lado derecho del operador
Original:
duration on the right-hand side of the operator
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
d -
el argumento de duración para los operadores mixtos argumentos
Original:
the duration argument for mixed-argument operators
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
s -
marque contar argumento para los operadores mixtos argumentos
Original:
tick count argument for mixed-argument operators
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[editar] Valor de retorno

Suponiendo que CD es el tipo de retorno de la función y CR<A, B> = std::common_type<A, B>::type, entonces:
Original:
Assuming that CD is the function return type and CR<A, B> = std::common_type<A, B>::type, then:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
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)
Original:
CD(lhs).count() / CD(rhs).count() (the return type of this operator is not a duration)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
7) CD(CD(d).count() % s)
8) CD(CD(lhs).count() % CD(rhs).count())


[editar] Ejemplo

#include <chrono>
#include <iostream>
int main()
{
    // simple arithmetic
    std::chrono::seconds s = std::chrono::hours(1) 
                             + 2*std::chrono::minutes(10)
                             + std::chrono::seconds(70)/10;
 
    std::cout << "1 hour + 2*10 min + 70/10 sec = " << s.count() << " seconds\n";
 
    // difference between dividing a duration by a number
    // and dividing a duration by another duration
    std::cout << "Dividing that by 2 minutes gives "
              << s / std::chrono::minutes(2) << '\n';
    std::cout << "Dividing that by 2 gives "
              << (s / 2).count() << " sconds\n";
 
   // the remainder operator is useful in determining where in a time
   // frame is this particular duration, e.g. to break it down into hours,
   // minutes, and seconds:
   std::cout << s.count() << " seconds is "
             << std::chrono::duration_cast<std::chrono::hours>(
                    s
                ).count() << " hours, "
             << std::chrono::duration_cast<std::chrono::minutes>(
                    s % std::chrono::hours(1)
                ).count() << " minutes, "
             << std::chrono::duration_cast<std::chrono::seconds>(
                    s % std::chrono::minutes(1)
                ).count() << " seconds\n";
}

Output:

1 hour + 2*10 min + 70/10 sec = 4807 seconds
Dividing that by 2 minutes gives 40
Dividing that by 2 gives 2403 sconds
4807 seconds is 1 hours, 20 minutes, 7 seconds