Namespaces
Variants
Views
Actions

operator==,!=,<,<=,>,>=,<=>(std::chrono::duration)

From cppreference.com
< cpp‎ | chrono‎ | duration
 
 
 
Date and time utilities
(C++11)
(C++11)
Clocks
(C++20)
                                             
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
Calendars
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
Time zones
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
C-style date and time
 
 
template <class Rep1, class Period1, class Rep2, class Period2>

constexpr bool operator==(const std::chrono::duration<Rep1, Period1>& lhs,

                          const std::chrono::duration<Rep2, Period2>& rhs);
(1) (since C++11)
template <class Rep1, class Period1, class Rep2, class Period2>

constexpr bool operator!=(const std::chrono::duration<Rep1, Period1>& lhs,

                          const std::chrono::duration<Rep2, Period2>& rhs);
(2) (since C++11)
(until C++20)
template <class Rep1, class Period1, class Rep2, class Period2>

constexpr bool operator<(const std::chrono::duration<Rep1, Period1>& lhs,

                         const std::chrono::duration<Rep2, Period2>& rhs);
(3) (since C++11)
(until C++20)
template <class Rep1, class Period1, class Rep2, class Period2>

constexpr bool operator<=(const std::chrono::duration<Rep1, Period1>& lhs,

                          const std::chrono::duration<Rep2, Period2>& rhs);
(4) (since C++11)
(until C++20)
template <class Rep1, class Period1, class Rep2, class Period2>

constexpr bool operator>(const std::chrono::duration<Rep1, Period1>& lhs,

                         const std::chrono::duration<Rep2, Period2>& rhs);
(5) (since C++11)
(until C++20)
template <class Rep1, class Period1, class Rep2, class Period2>

constexpr bool operator>=(const std::chrono::duration<Rep1, Period1>& lhs,

                          const std::chrono::duration<Rep2, Period2>& rhs);
(6) (since C++11)
(until C++20)
template <class Rep1, class Period1, class Rep2, class Period2>

    requires std::three_way_comparable<std::common_type_t<Rep1, Rep2>>
constexpr auto operator<=>(const std::chrono::duration<Rep1, Period1>& lhs,

                           const std::chrono::duration<Rep2, Period2>& rhs);
(7) (since C++20)

Compares two durations. Let CT be std::common_type<std::chrono::duration<Rep1, Period1>, std::chrono::duration<Rep2, Period2>>::type:

1-2) Checks if lhs and rhs are equal, i.e. the number of ticks for the type common to both durations are equal.
3-6) Compares lhs to rhs, i.e. compares the number of ticks for the type common to both durations.
7) Compares lhs to rhs, i.e. compares the number of ticks for the type common to both durations. The return type is deduced from CT(lhs).count() <=> CT(rhs).count().

[edit] Parameters

lhs - duration on the left-hand side of the operator
rhs - duration on the right-hand side of the operator

[edit] Return value

1) CT(lhs).count() == CT(rhs).count()
2) !(lhs == rhs)
3) CT(lhs).count() < CT(rhs).count()
4) !(rhs < lhs)
5) rhs < lhs
6) !(lhs < rhs)
7) CT(lhs).count() <=> CT(rhs).count()

[edit] Example

#include <chrono>
#include <iostream>
int main()
{
    if(std::chrono::seconds(2) == std::chrono::milliseconds(2000))
        std::cout <<  "2 s == 2000 ms\n";
    else
        std::cout <<  "2 s != 2000 ms\n";
 
    if(std::chrono::seconds(61) > std::chrono::minutes(1))
        std::cout <<  "61 s > 1 min\n";
    else
        std::cout <<  "61 s <= 1 min\n";
 
}

Output:

2 s == 2000 ms
61 s > 1 min