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

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

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

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.

| This section is incomplete Reason: list the "does not participate in overload resolution unless" constraints

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

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/chrono/duration/operator_arith4&oldid=81529"
Category:

- Todo with reason