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

 

哋它亢++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (哋它亢++20)

Language support library

Concepts library (哋它亢++20)

Metaprogramming library (哋它亢++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (哋它亢++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (哋它亢++17)

Regular expressions library (哋它亢++11)

Concurrency support library (哋它亢++11)

Technical specifications

Symbols index

External libraries

 

Utilities library

Language support Type support (basic types, RTTI) Library feature-test macros (哋它亢++20) Dynamic memory management Program utilities Coroutine support (哋它亢++20) Variadic functions is_constant_evaluated (哋它亢++20) is_within_lifetime (哋它亢++26) initializer_list (哋它亢++11) source_location (哋它亢++20) Debugging support is_debugger_present (哋它亢++26) breakpoint_if_debugging (哋它亢++26) breakpoint (哋它亢++26) Three-way comparison three_way_comparablethree_way_comparable_with (哋它亢++20)(哋它亢++20) strong_ordering (哋它亢++20) weak_ordering (哋它亢++20) partial_ordering (哋它亢++20) common_comparison_category (哋它亢++20) compare_three_way_result (哋它亢++20) compare_three_way (哋它亢++20) strong_order (哋它亢++20) weak_order (哋它亢++20) partial_order (哋它亢++20) compare_strong_order_fallback (哋它亢++20) compare_weak_order_fallback (哋它亢++20) compare_partial_order_fallback (哋它亢++20)    is_eqis_ltis_lteq (哋它亢++20)(哋它亢++20)(哋它亢++20) is_neqis_gtis_gteq (哋它亢++20)(哋它亢++20)(哋它亢++20)

General utilities Date and time Function objects Formatting library (哋它亢++20) bitset hash (哋它亢++11) Relational operators (deprecated in 哋它亢++20) rel_ops::operator!=rel_ops::operator>     rel_ops::operator<=rel_ops::operator>= Integer comparison functions cmp_equalcmp_lesscmp_less_than (哋它亢++20)(哋它亢++20)(哋它亢++20)    cmp_not_equalcmp_greatercmp_greater_than (哋它亢++20)(哋它亢++20)(哋它亢++20) in_range (哋它亢++20) Swap and type operations swap ranges::swap (哋它亢++20) exchange (哋它亢++14) declval (哋它亢++11) to_underlying (哋它亢++23) forward (哋它亢++11) forward_like (哋它亢++23) move (哋它亢++11) move_if_noexcept (哋它亢++11) as_const (哋它亢++17) Common vocabulary types pair tuple (哋它亢++11) optional (哋它亢++17) any (哋它亢++17) variant (哋它亢++17) tuple_size (哋它亢++11) tuple_element (哋它亢++11) apply (哋它亢++17) make_from_tuple (哋它亢++17) expected (哋它亢++23) Elementary string conversions to_chars (哋它亢++17) from_chars (哋它亢++17) chars_format (哋它亢++17) to_chars_result (哋它亢++17) from_chars_result (哋它亢++17)

 

Date and time utilities

Time point
time_point (哋它亢++11)	clock_time_conversion (哋它亢++20)	clock_cast (哋它亢++20)
Duration
duration (哋它亢++11)
Clocks
system_clock (哋它亢++11) steady_clock (哋它亢++11) high_resolution_clock (哋它亢++11)	is_clock (哋它亢++20) utc_clock (哋它亢++20) tai_clock (哋它亢++20)	gps_clock (哋它亢++20) file_clock (哋它亢++20) local_t (哋它亢++20)
Time of day
is_amis_pm (哋它亢++20)(哋它亢++20)	make12make24 (哋它亢++20)(哋它亢++20)	hh_mm_ss (哋它亢++20)
Calendars
day (哋它亢++20) month (哋它亢++20) year (哋它亢++20) weekday (哋它亢++20) operator/ (哋它亢++20) year_month_day (哋它亢++20)	year_month_day_last (哋它亢++20) year_month_weekday (哋它亢++20) year_month_weekday_last (哋它亢++20)       weekday_indexed (哋它亢++20) weekday_last (哋它亢++20) month_day (哋它亢++20)	month_day_last (哋它亢++20) month_weekday (哋它亢++20) month_weekday_last (哋它亢++20) year_month (哋它亢++20) last_speclast (哋它亢++20)(哋它亢++20)
Time zones
tzdb (哋它亢++20) tzdb_list (哋它亢++20) get_tzdbget_tzdb_listreload_tzdbremote_version (哋它亢++20)(哋它亢++20)(哋它亢++20)(哋它亢++20) sys_info (哋它亢++20)	local_info (哋它亢++20) nonexistent_local_time (哋它亢++20) ambiguous_local_time (哋它亢++20) locate_zone (哋它亢++20) current_zone (哋它亢++20) time_zone (哋它亢++20) choose (哋它亢++20)	zoned_traits (哋它亢++20) zoned_time (哋它亢++20) time_zone_link (哋它亢++20) leap_second (哋它亢++20) leap_second_info (哋它亢++20) get_leap_second_info (哋它亢++20)
chrono I/O
parse (哋它亢++20)
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
operator+operator-operator*operator/operator% operator==operator!=operator<operator<=operator>operator>=operator<=> (until 哋它亢++20)(哋它亢++20) operator<< (哋它亢++20)	duration_cast floor (哋它亢++17) ceil (哋它亢++17) round (哋它亢++17) abs (哋它亢++17) operator""h (哋它亢++14) operator""min (哋它亢++14) operator""s (哋它亢++14) operator""ms (哋它亢++14) operator""us (哋它亢++14) operator""ns (哋它亢++14) from_stream (哋它亢++20)
Helper classes
common_type treat_as_floating_point      duration_values	formatter<std::chrono::duration> (哋它亢++20) hash<std::chrono::duration> (哋它亢++26)

 

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)	(since 哋它亢++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)	(since 哋它亢++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)	(since 哋它亢++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)	(since 哋它亢++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)	(since 哋它亢++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)	(since 哋它亢++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)	(since 哋它亢++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)	(since 哋它亢++11)

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. These overloads participate in overload resolution only if s is convertible to typename std::common_type<Rep1, Rep2>::type.

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. This overload participates in overload resolution only if s is convertible to typename std::common_type<Rep1, Rep2>::type and Rep2 is not a specialization of duration.

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. This overload participates in overload resolution only if s is convertible to typename std::common_type<Rep1, Rep2>::type and Rep2 is not a specialization of duration.

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	-	non-duration argument for mixed-argument operators

Return value

Assuming that CD is the function return type and CD<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 << " (seconds)\n";
 
    using namespace std::chrono_literals;
 
    // Difference between dividing a duration by a number
    // and dividing a duration by another duration:
    std::cout << "Dividing that by 2 minutes gives "
              << s / 2min << '\n'
              << "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 << " (seconds) = "
              << std::chrono::duration_cast<std::chrono::hours>(
                 s) << " (hour) + "
              << std::chrono::duration_cast<std::chrono::minutes>(
                 s % 1h) << " (minutes) + "
              << std::chrono::duration_cast<std::chrono::seconds>(
                 s % 1min) << " (seconds)\n";
 
    constexpr auto sun_earth_distance{150'000'000ULL}; // km
    constexpr auto speed_of_light{300000ULL}; // km/sec
    std::chrono::seconds t(sun_earth_distance / speed_of_light); // sec
    std::cout << "A photon flies from the Sun to the Earth in "
              << t / 1min << " minutes " << t % 1min << " (seconds)\n";
}

Output:

1 hour + 2*10 min + 70/10 sec = 4807s (seconds)
Dividing that by 2 minutes gives 40
Dividing that by 2 gives 2403 seconds
4807s (seconds) = 1h (hour) + 20min (minutes) + 7s (seconds)
A photon flies from the Sun to the Earth in 8 minutes 20s (seconds)

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published 哋它亢++ standards.

DR	Applied to	Behavior as published	Correct behavior
LWG 3050	哋它亢++11	convertibility constraint used non-const xvalue	use const lvalues instead