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

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

 

Utilities library

Type support (basic types, RTTI, type traits)

Dynamic memory management

Error handling

Program utilities

Variadic functions

Date and time

Function objects

initializer_list (C++11)

bitset

hash (C++11)

Relational operators

rel_ops::operator!= rel_ops::operator> rel_ops::operator<= rel_ops::operator>=

Pairs and tuples

pair

tuple (C++11)

piecewise_construct_t (C++11)

piecewise_construct (C++11)

Swap, forward and move

swap

forward (C++11)

move (C++11)

move_if_noexcept (C++11)

declval (C++11)

 

Date and time utilities

time_point (C++11)

duration (C++11)

system_clock (C++11)

steady_clock (C++11)

high_resolution_clock (C++11)

C-style date and time

 

std::chrono::duration

Member functions

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%=

Non-member functions

common_type

operator+ operator- operator* operator/ operator%

operator== operator!= operator< operator<= operator> operator>=

duration_cast

Helper classes

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)

Performs basic arithmetic operations between two durations or between a duration and a tick count.

1) Converts the two durations to their common type and creates a duration whose tick count is the sum of the tick counts after conversion.

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

3-4) 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.

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

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

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

8) Converts the two durations to their common type and creates a duration whose tick count is the remainder of the tick counts after conversion.

Parameters

lhs	-	duration on the left-hand side of the operator
rhs	-	duration on the right-hand side of the operator
d	-	the duration argument for mixed-argument operators
s	-	tick count argument for mixed-argument operators

Return value

Assuming that CD is the function return type and CR<A, B> = std::common_type<A, B>::type, then:

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() (the return type of this operator is not a duration)

7) CD(CD(d).count() % s)

8) CD(CD(lhs).count() % CD(rhs).count())

Example

run this code

#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() << " seconds\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 seconds
4807 seconds is 1 hours, 20 minutes, 7 seconds