27 Time library [time]

27.6 Class template time_­point [time.point]

namespace std::chrono {
  template<class Clock, class Duration = typename Clock::duration>
  class time_point {
  public:
    using clock    = Clock;
    using duration = Duration;
    using rep      = typename duration::rep;
    using period   = typename duration::period;

  private:
    duration d_;                                                // exposition only

  public:
    // [time.point.cons], construct
    constexpr time_point();                                     // has value epoch
    constexpr explicit time_point(const duration& d);           // same as time_­point() + d
    template<class Duration2>
      constexpr time_point(const time_point<clock, Duration2>& t);

    // [time.point.observer], observer
    constexpr duration time_since_epoch() const;

    // [time.point.arithmetic], arithmetic
    constexpr time_point& operator++();
    constexpr time_point operator++(int);
    constexpr time_point& operator--();
    constexpr time_point operator--(int);
    constexpr time_point& operator+=(const duration& d);
    constexpr time_point& operator-=(const duration& d);

    // [time.point.special], special values
    static constexpr time_point min() noexcept;
    static constexpr time_point max() noexcept;
  };
}
1
#
Clock shall either meet the Cpp17Clock requirements ([time.clock.req]) or be the type local_­t.
2
#
If Duration is not an instance of duration, the program is ill-formed.

27.6.1 Constructors [time.point.cons]

🔗
constexpr time_point();
1
#
Effects: Initializes d_­ with duration​::​zero().
Such a time_­point object represents the epoch.
🔗
constexpr explicit time_point(const duration& d);
2
#
Effects: Initializes d_­ with d.
Such a time_­point object represents the epoch + d.
🔗
template<class Duration2> constexpr time_point(const time_point<clock, Duration2>& t);
3
#
Constraints: is_­convertible_­v<Duration2, duration> is true.
4
#
Effects: Initializes d_­ with t.time_­since_­epoch().

27.6.2 Observer [time.point.observer]

🔗
constexpr duration time_since_epoch() const;
1
#
Returns: d_­.

27.6.3 Arithmetic [time.point.arithmetic]

🔗
constexpr time_point& operator++();
1
#
Effects: Equivalent to: ++d_­.
2
#
Returns: *this.
🔗
constexpr time_point operator++(int);
3
#
Effects: Equivalent to: return time_­point{d_­++};
🔗
constexpr time_point& operator--();
4
#
Effects: Equivalent to: --d_­.
5
#
Returns: *this.
🔗
constexpr time_point operator--(int);
6
#
Effects: Equivalent to: return time_­point{d_­--};
🔗
constexpr time_point& operator+=(const duration& d);
7
#
Effects: Equivalent to: d_­ += d.
8
#
Returns: *this.
🔗
constexpr time_point& operator-=(const duration& d);
9
#
Effects: Equivalent to: d_­ -= d.
10
#
Returns: *this.

27.6.4 Special values [time.point.special]

🔗
static constexpr time_point min() noexcept;
1
#
Returns: time_­point(duration​::​min()).
🔗
static constexpr time_point max() noexcept;
2
#
Returns: time_­point(duration​::​max()).

27.6.5 Non-member arithmetic [time.point.nonmember]

🔗
template<class Clock, class Duration1, class Rep2, class Period2> constexpr time_point<Clock, common_type_t<Duration1, duration<Rep2, Period2>>> operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
1
#
Returns: CT(lhs.time_­since_­epoch() + rhs), where CT is the type of the return value.
🔗
template<class Rep1, class Period1, class Clock, class Duration2> constexpr time_point<Clock, common_type_t<duration<Rep1, Period1>, Duration2>> operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);
2
#
Returns: rhs + lhs.
🔗
template<class Clock, class Duration1, class Rep2, class Period2> constexpr time_point<Clock, common_type_t<Duration1, duration<Rep2, Period2>>> operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
3
#
Returns: CT(lhs.time_­since_­epoch() - rhs), where CT is the type of the return value.
🔗
template<class Clock, class Duration1, class Duration2> constexpr common_type_t<Duration1, Duration2> operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
4
#
Returns: lhs.time_­since_­epoch() - rhs.time_­since_­epoch().

27.6.6 Comparisons [time.point.comparisons]

🔗
template<class Clock, class Duration1, class Duration2> constexpr bool operator==(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
1
#
Returns: lhs.time_­since_­epoch() == rhs.time_­since_­epoch().
🔗
template<class Clock, class Duration1, class Duration2> constexpr bool operator<(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
2
#
Returns: lhs.time_­since_­epoch() < rhs.time_­since_­epoch().
🔗
template<class Clock, class Duration1, class Duration2> constexpr bool operator>(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
3
#
Returns: rhs < lhs.
🔗
template<class Clock, class Duration1, class Duration2> constexpr bool operator<=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
4
#
Returns: !(rhs < lhs).
🔗
template<class Clock, class Duration1, class Duration2> constexpr bool operator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
5
#
Returns: !(lhs < rhs).
🔗
template<class Clock, class Duration1, three_­way_­comparable_­with<Duration1> Duration2> constexpr auto operator<=>(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
6
#
Returns: lhs.time_­since_­epoch() <=> rhs.time_­since_­epoch().

27.6.7 Conversions [time.point.cast]

🔗
template<class ToDuration, class Clock, class Duration> constexpr time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);
1
#
Constraints: ToDuration is a specialization of duration.
2
#
Returns: 
time_point<Clock, ToDuration>(duration_cast<ToDuration>(t.time_since_epoch()))
🔗
template<class ToDuration, class Clock, class Duration> constexpr time_point<Clock, ToDuration> floor(const time_point<Clock, Duration>& tp);
3
#
Constraints: ToDuration is a specialization of duration.
4
#
Returns: time_­point<Clock, ToDuration>(floor<ToDuration>(tp.time_­since_­epoch())).
🔗
template<class ToDuration, class Clock, class Duration> constexpr time_point<Clock, ToDuration> ceil(const time_point<Clock, Duration>& tp);
5
#
Constraints: ToDuration is a specialization of duration.
6
#
Returns: time_­point<Clock, ToDuration>(ceil<ToDuration>(tp.time_­since_­epoch())).
🔗
template<class ToDuration, class Clock, class Duration> constexpr time_point<Clock, ToDuration> round(const time_point<Clock, Duration>& tp);
7
#
Constraints: ToDuration is a specialization of duration, and treat_­as_­floating_­point_­v<typename ToDuration​::​rep> is false.
8
#
Returns: time_­point<Clock, ToDuration>(round<ToDuration>(tp.time_­since_­epoch())).