23 General utilities library [utilities]

23.17 Time utilities [time]

23.17.1 In general [time.general]

1
#

В этом подпункте описываются chrono library и различные, C functions которые предоставляют обычно полезные утилиты времени.

23.17.2 Header <chrono> synopsis [time.syn]

namespace std {
  namespace chrono {
    // [time.duration], class template duration
    template <class Rep, class Period = ratio<1>> class duration;

    // [time.point], class template time_­point
    template <class Clock, class Duration = typename Clock::duration> class time_point;
  }

  // [time.traits.specializations], common_­type specializations
  template <class Rep1, class Period1, class Rep2, class Period2>
    struct common_type<chrono::duration<Rep1, Period1>,
                       chrono::duration<Rep2, Period2>>;

  template <class Clock, class Duration1, class Duration2>
    struct common_type<chrono::time_point<Clock, Duration1>,
                       chrono::time_point<Clock, Duration2>>;

  namespace chrono {
    // [time.traits], customization traits
    template <class Rep> struct treat_as_floating_point;
    template <class Rep> struct duration_values;
    template <class Rep> inline constexpr bool treat_as_floating_point_v
      = treat_as_floating_point<Rep>::value;

    // [time.duration.nonmember], duration arithmetic
    template <class Rep1, class Period1, class Rep2, class Period2>
      common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
      constexpr operator+(const duration<Rep1, Period1>& lhs,
                          const duration<Rep2, Period2>& rhs);
    template <class Rep1, class Period1, class Rep2, class Period2>
      common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
      constexpr operator-(const duration<Rep1, Period1>& lhs,
                          const duration<Rep2, Period2>& rhs);
    template <class Rep1, class Period, class Rep2>
      duration<common_type_t<Rep1, Rep2>, Period>
      constexpr operator*(const duration<Rep1, Period>& d, const Rep2& s);
    template <class Rep1, class Rep2, class Period>
      duration<common_type_t<Rep1, Rep2>, Period>
      constexpr operator*(const Rep1& s, const duration<Rep2, Period>& d);
    template <class Rep1, class Period, class Rep2>
      duration<common_type_t<Rep1, Rep2>, Period>
      constexpr operator/(const duration<Rep1, Period>& d, const Rep2& s);
    template <class Rep1, class Period1, class Rep2, class Period2>
      common_type_t<Rep1, Rep2>
      constexpr operator/(const duration<Rep1, Period1>& lhs,
                          const duration<Rep2, Period2>& rhs);
    template <class Rep1, class Period, class Rep2>
      duration<common_type_t<Rep1, Rep2>, Period>
      constexpr operator%(const duration<Rep1, Period>& d, const Rep2& s);
    template <class Rep1, class Period1, class Rep2, class Period2>
      common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
      constexpr operator%(const duration<Rep1, Period1>& lhs,
                          const duration<Rep2, Period2>& rhs);

    // [time.duration.comparisons], duration comparisons
    template <class Rep1, class Period1, class Rep2, class Period2>
      constexpr bool operator==(const duration<Rep1, Period1>& lhs,
                                const duration<Rep2, Period2>& rhs);
    template <class Rep1, class Period1, class Rep2, class Period2>
      constexpr bool operator!=(const duration<Rep1, Period1>& lhs,
                                const duration<Rep2, Period2>& rhs);
    template <class Rep1, class Period1, class Rep2, class Period2>
      constexpr bool operator< (const duration<Rep1, Period1>& lhs,
                                const duration<Rep2, Period2>& rhs);
    template <class Rep1, class Period1, class Rep2, class Period2>
      constexpr bool operator<=(const duration<Rep1, Period1>& lhs,
                                const duration<Rep2, Period2>& rhs);
    template <class Rep1, class Period1, class Rep2, class Period2>
      constexpr bool operator> (const duration<Rep1, Period1>& lhs,
                                const duration<Rep2, Period2>& rhs);
    template <class Rep1, class Period1, class Rep2, class Period2>
      constexpr bool operator>=(const duration<Rep1, Period1>& lhs,
                                const duration<Rep2, Period2>& rhs);

    // [time.duration.cast], duration_­cast
    template <class ToDuration, class Rep, class Period>
      constexpr ToDuration duration_cast(const duration<Rep, Period>& d);
    template <class ToDuration, class Rep, class Period>
      constexpr ToDuration floor(const duration<Rep, Period>& d);
    template <class ToDuration, class Rep, class Period>
      constexpr ToDuration ceil(const duration<Rep, Period>& d);
    template <class ToDuration, class Rep, class Period>
      constexpr ToDuration round(const duration<Rep, Period>& d);

    // convenience typedefs
    using nanoseconds  = duration<signed integer type of at least 64 bits, nano>;
    using microseconds = duration<signed integer type of at least 55 bits, micro>;
    using milliseconds = duration<signed integer type of at least 45 bits, milli>;
    using seconds      = duration<signed integer type of at least 35 bits>;
    using minutes      = duration<signed integer type of at least 29 bits, ratio<  60>>;
    using hours        = duration<signed integer type of at least 23 bits, ratio<3600>>;

    // [time.point.nonmember], time_­point arithmetic
    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);
    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);
    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);
    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);

    // [time.point.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);
    template <class Clock, class Duration1, class Duration2>
       constexpr bool operator!=(const time_point<Clock, Duration1>& lhs,
                                 const time_point<Clock, Duration2>& rhs);
    template <class Clock, class Duration1, class Duration2>
       constexpr bool operator< (const time_point<Clock, Duration1>& lhs,
                                 const time_point<Clock, Duration2>& rhs);
    template <class Clock, class Duration1, class Duration2>
       constexpr bool operator<=(const time_point<Clock, Duration1>& lhs,
                                 const time_point<Clock, Duration2>& rhs);
    template <class Clock, class Duration1, class Duration2>
       constexpr bool operator> (const time_point<Clock, Duration1>& lhs,
                                 const time_point<Clock, Duration2>& rhs);
    template <class Clock, class Duration1, class Duration2>
       constexpr bool operator>=(const time_point<Clock, Duration1>& lhs,
                                 const time_point<Clock, Duration2>& rhs);

    // [time.point.cast], time_­point_­cast
    template <class ToDuration, class Clock, class Duration>
      constexpr time_point<Clock, ToDuration>
      time_point_cast(const time_point<Clock, Duration>& t);
    template <class ToDuration, class Clock, class Duration>
      constexpr time_point<Clock, ToDuration>
      floor(const time_point<Clock, Duration>& tp);
    template <class ToDuration, class Clock, class Duration>
      constexpr time_point<Clock, ToDuration>
      ceil(const time_point<Clock, Duration>& tp);
    template <class ToDuration, class Clock, class Duration>
      constexpr time_point<Clock, ToDuration>
      round(const time_point<Clock, Duration>& tp);

    // [time.duration.alg], specialized algorithms
    template <class Rep, class Period>
      constexpr duration<Rep, Period> abs(duration<Rep, Period> d);

    // [time.clock], clocks
    class system_clock;
    class steady_clock;
    class high_resolution_clock;
  }

  inline namespace literals {
    inline namespace chrono_literals {
      // [time.duration.literals], suffixes for duration literals
      constexpr chrono::hours                                operator""h(unsigned long long);
      constexpr chrono::duration<unspecified, ratio<3600,1>> operator""h(long double);
      constexpr chrono::minutes                              operator""min(unsigned long long);
      constexpr chrono::duration<unspecified, ratio<60,1>>   operator""min(long double);
      constexpr chrono::seconds                              operator""s(unsigned long long);
      constexpr chrono::duration<unspecified>                operator""s(long double);
      constexpr chrono::milliseconds                         operator""ms(unsigned long long);
      constexpr chrono::duration<unspecified, milli>          operator""ms(long double);
      constexpr chrono::microseconds                         operator""us(unsigned long long);
      constexpr chrono::duration<unspecified, micro>         operator""us(long double);
      constexpr chrono::nanoseconds                          operator""ns(unsigned long long);
      constexpr chrono::duration<unspecified, nano>          operator""ns(long double);
    }
  }

  namespace chrono {
    using namespace literals::chrono_literals;
  }
}

23.17.3 Clock requirements [time.clock.req]

1
#

Часы - это связка, состоящая из a duration, a time_­pointи функции now() для получения тока time_­point. Происхождение часов time_­point называется часами epoch. Часы должны соответствовать требованиям таблицы 52.

2
#

В таблице 52 C1 и цвет, C2 обозначают типы тактовых импульсов. t1 и t2 являются значениями, возвращаемыми тем C1​::​now() местом, где вызов возвращает возвращаемый t1 happens before вызов, t2 и оба этих вызова произошли раньше C1​::​time_­point​::​max(). [  Note: Это означает, C1 что не нужно переходить между t1 и t2. ]  — end note 

Таблица 52 - Требования к часам
ВыражениеТип возвратаОперационная семантика
C1​::​rep Арифметический тип или класс, имитирующий арифметический тип Тип представления C1​::​duration.
C1​::​period специализация ratio Период тика часов в секундах.
C1​::​duration chrono​::​duration<C1​::​rep, C1​::​period> duration Тип часов.
C1​::​time_­point chrono​::​time_­point<C1> или chrono​::​time_­point<C2, C1​::​duration> time_­point Тип часов. C1 и C2 будет относиться к той же эпохе.
C1​::​is_­steady const bool true если t1 <= t2 всегда, true а время между тактами часов постоянно, в противном случае false.
C1​::​now() C1​::​time_­point Возвращает time_­point объект, представляющий текущий момент времени.
3
#

[  Note: Относительная разница в продолжительности между теми, о которых сообщают данные часы и определение SI, является мерой качества реализации. ]  — end note 

4
#

Тип TC соответствует TrivialClock требованиям, если:

  • (4.1)

    TC удовлетворяет Clock requirements,

  • (4.2)

    типы TC​::​rep, TC​::​durationи TC​::​time_­point удовлетворяют требования EqualityComparable, LessThanComparable, DefaultConstructible, CopyConstructible, CopyAssignable, Destructible, и требование о numeric types. [  Note: Это, в частности, означает, что операции с этими типами не вызывают исключений. ]  — end note 

  • (4.3)

    lvalues этих типов TC​::​rep, TC​::​durationи TC​::​time_­point являются swappable,

  • (4.4)

    функция TC​::​now() не генерирует исключений и

  • (4.5)

    тип TC​::​time_­point​::​clock соответствует TrivialClock требованиям, рекурсивно.

23.17.4 Time-related traits [time.traits]

23.17.4.1 treat_­as_­floating_­point [time.traits.is_fp]

template <class Rep> struct treat_as_floating_point : is_floating_point<Rep> { };

1
#

В duration использует шаблон по treat_­as_­floating_­point черту , чтобы помочь определить , если duration объект может быть преобразован в другой duration с другим клещом period. Если treat_­as_­floating_­point_­v<Rep> есть true, то среди durations разрешены неявные преобразования . В противном случае неявная конвертируемость зависит от отметки periods в durationстроке s. [  Note: Цель этой черты - указать, ведет ли данный класс как тип с плавающей запятой, и, таким образом, разрешает деление одного значения на другое с приемлемой потерей точности. Если treat_­as_­floating_­point_­v<Rep> есть false, Rep будет рассматриваться, как если бы он вел себя как интегральный тип для целей этих преобразований. ] — end note 

23.17.4.2 duration_­values [time.traits.duration_values]

template <class Rep> struct duration_values { public: static constexpr Rep zero(); static constexpr Rep min(); static constexpr Rep max(); };

1
#

duration Шаблон использует duration_­values признак , чтобы построить специальные значения представления длительностей (Rep). Это сделано потому, что представление может быть типом класса с поведением, которое требует, чтобы какая-то другая реализация возвращала эти специальные значения. В этом случае автор этого типа класса должен специализироваться duration_­values на возврате указанных значений.

static constexpr Rep zero();

2
#

Returns: Rep(0). [  Note: Rep(0) указывается вместо, Rep() потому что Rep() может иметь другое значение, например, неинициализированное значение. ]  — end note 

3
#

Remarks: Возвращаемое значение должно быть дополнительным идентификатором.

static constexpr Rep min();

4
#

Returns: numeric_­limits<Rep>​::​lowest().

5
#

Remarks: Возвращаемое значение должно быть меньше или равно zero().

static constexpr Rep max();

6
#

Returns: numeric_­limits<Rep>​::​max().

7
#

Remarks: Возвращаемое значение должно быть больше чем zero().

23.17.4.3 Specializations of common_­type [time.traits.specializations]

template <class Rep1, class Period1, class Rep2, class Period2> struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2>> { using type = chrono::duration<common_type_t<Rep1, Rep2>, see below>; };

1
#

period Из duration обозначено этой специализации common_­type должны быть наибольший общий делитель Period1 и Period2. [  Note: Это можно вычислить, образуя отношение наибольшего общего делителя Period1​::​num и Period2​::​num и наименьшего общего кратного Period1​::​den и Period2​::​den. ] — end note 

2
#

[ Имя является синонимом для с самым большим клеща возможно , когда оба аргумента будет конвертировать в него , не требуя операции деления. Представление этого типа предназначено для того, чтобы иметь возможность хранить любое значение, полученное в результате этого преобразования, без ошибки усечения, хотя длительности с плавающей запятой могут иметь ошибки округления. ] Note: typedef type duration period duration  — end note 

template <class Clock, class Duration1, class Duration2> struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2>> { using type = chrono::time_point<Clock, common_type_t<Duration1, Duration2>>; };

3
#

Общий тип двух time_­point типов - это time_­point с теми же часами, что и два типа, и общий тип их двух durations.

23.17.5 Class template duration [time.duration]

1
#

duration Меры типа времени между двумя точками во времени (time_­pointсек). A duration имеет представление, которое содержит количество тиков и период тиков. Тиковый период - это количество времени, которое происходит от одного тика до следующего, в секундах. Он выражается как рациональная константа с помощью шаблона ratio.

template <class Rep, class Period = ratio<1>>
class duration {
public:
  using rep    = Rep;
  using period = typename Period::type;
private:
  rep rep_;  // exposition only
public:
  // [time.duration.cons], construct/copy/destroy
  constexpr duration() = default;
  template <class Rep2>
      constexpr explicit duration(const Rep2& r);
  template <class Rep2, class Period2>
     constexpr duration(const duration<Rep2, Period2>& d);
  ~duration() = default;
  duration(const duration&) = default;
  duration& operator=(const duration&) = default;

  // [time.duration.observer], observer
  constexpr rep count() const;

  // [time.duration.arithmetic], arithmetic
  constexpr common_type_t<duration> operator+() const;
  constexpr common_type_t<duration> operator-() const;
  constexpr duration& operator++();
  constexpr duration  operator++(int);
  constexpr duration& operator--();
  constexpr duration  operator--(int);

  constexpr duration& operator+=(const duration& d);
  constexpr duration& operator-=(const duration& d);

  constexpr duration& operator*=(const rep& rhs);
  constexpr duration& operator/=(const rep& rhs);
  constexpr duration& operator%=(const rep& rhs);
  constexpr duration& operator%=(const duration& rhs);

  // [time.duration.special], special values
  static constexpr duration zero();
  static constexpr duration min();
  static constexpr duration max();
};
2
#

Rep должен быть арифметическим типом или классом, имитирующим арифметический тип. Если duration создается экземпляр с duration типом в качестве аргумента для параметра шаблона Rep, программа имеет неправильный формат.

3
#

Если Period это не специализация ratio, программа плохо сформирована. Если Period​::​num не положительный, программа неправильно сформирована.

4
#

Члены duration не должны бросать исключения, кроме тех, которые выбрасываются указанными операциями на их представления.

5
#

Конструктор копирования по умолчанию для duration должен быть функцией constexpr тогда и только тогда, когда требуемая инициализация члена rep_­ для копирования и перемещения, соответственно, удовлетворяет требованиям для функции constexpr.

6
#

[ Example: 

duration<long, ratio<60>> d0;       // holds a count of minutes using a long
duration<long long, milli> d1;      // holds a count of milliseconds using a long long
duration<double, ratio<1, 30>>  d2; // holds a count with a tick period of 130 of a second
                                    // (30 Hz) using a double

 — end example ]

23.17.5.1 duration constructors [time.duration.cons]

template <class Rep2> constexpr explicit duration(const Rep2& r);

1
#

Remarks: Этот конструктор не должен участвовать в разрешении перегрузки, если он не Rep2 может быть неявно преобразован в rep и

  • (1.1)

    treat_­as_­floating_­point_­v<rep> есть true или

  • (1.2)

    treat_­as_­floating_­point_­v<Rep2> есть false.

[ Example: 

duration<int, milli> d(3);          // OK
duration<int, milli> d(3.5);        // error

 — end example ]

2
#

Effects: Создает объект типа duration.

3
#

Postconditions: count() == static_­cast<rep>(r).

template <class Rep2, class Period2> constexpr duration(const duration<Rep2, Period2>& d);

4
#

Remarks: Этот конструктор не должен участвовать в разрешении перегрузки, если при преобразовании не индуцируется переполнение и treat_­as_­floating_­point_­v<rep> есть true или оба они ratio_­divide<Period2, period>​::​den есть 1 и treat_­as_­floating_­point_­v<Rep2> есть false. [  Note: Это требование предотвращает неявную ошибку усечения при преобразовании между целочисленными duration типами. Такая конструкция может легко привести к путанице в отношении стоимости duration. ] [  — end note  Example: 

duration<int, milli> ms(3);
duration<int, micro> us = ms;       // OK
duration<int, milli> ms2 = us;      // error

 — end example ]

5
#

Effects: Создает объект типа duration, построенный rep_­ из
duration_­cast<duration>(d).count().

23.17.5.2 duration observer [time.duration.observer]

constexpr rep count() const;

1
#

Returns: rep_­.

23.17.5.3 duration arithmetic [time.duration.arithmetic]

constexpr common_type_t<duration> operator+() const;

1
#

Returns: common_­type_­t<duration>(*this).

constexpr common_type_t<duration> operator-() const;

2
#

Returns: common_­type_­t<duration>(-rep_­).

constexpr duration& operator++();

3
#

Effects: Как будто мимо ++rep_­.

4
#

Returns: *this.

constexpr duration operator++(int);

5
#

Returns: duration(rep_­++).

constexpr duration& operator--();

6
#

Effects: Как будто мимо --rep_­.

7
#

Returns: *this.

constexpr duration operator--(int);

8
#

Returns: duration(rep_­--).

constexpr duration& operator+=(const duration& d);

9
#

Effects: Как будто по: rep_­ += d.count();

10
#

Returns: *this.

constexpr duration& operator-=(const duration& d);

11
#

Effects: Как будто по: rep_­ -= d.count();

12
#

Returns: *this.

constexpr duration& operator*=(const rep& rhs);

13
#

Effects: Как будто по: rep_­ *= rhs;

14
#

Returns: *this.

constexpr duration& operator/=(const rep& rhs);

15
#

Effects: Как будто по: rep_­ /= rhs;

16
#

Returns: *this.

constexpr duration& operator%=(const rep& rhs);

17
#

Effects: Как будто по: rep_­ %= rhs;

18
#

Returns: *this.

constexpr duration& operator%=(const duration& rhs);

19
#

Effects: Как будто по: rep_­ %= rhs.count();

20
#

Returns: *this.

23.17.5.4 duration special values [time.duration.special]

static constexpr duration zero();

1
#

Returns: duration(duration_­values<rep>​::​zero()).

static constexpr duration min();

2
#

Returns: duration(duration_­values<rep>​::​min()).

static constexpr duration max();

3
#

Returns: duration(duration_­values<rep>​::​max()).

23.17.5.5 duration non-member arithmetic [time.duration.nonmember]

1
#

В нижеследующих описаниях функций CD представляет тип возвращаемого значения функции. CR(A, B) представляет common_­type_­t<A, B>.

template <class Rep1, class Period1, class Rep2, class Period2> constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>> operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

2
#

Returns: CD(CD(lhs).count() + CD(rhs).count()).

template <class Rep1, class Period1, class Rep2, class Period2> constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>> operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

3
#

Returns: CD(CD(lhs).count() - CD(rhs).count()).

template <class Rep1, class Period, class Rep2> constexpr duration<common_type_t<Rep1, Rep2>, Period> operator*(const duration<Rep1, Period>& d, const Rep2& s);

4
#

Remarks: Этот оператор не должен участвовать в разрешении перегрузки, если он не Rep2 может быть неявно преобразован в CR(Rep1, Rep2).

5
#

Returns: CD(CD(d).count() * s).

template <class Rep1, class Rep2, class Period> constexpr duration<common_type_t<Rep1, Rep2>, Period> operator*(const Rep1& s, const duration<Rep2, Period>& d);

6
#

Remarks: Этот оператор не должен участвовать в разрешении перегрузки, если он не Rep1 может быть неявно преобразован в CR(Rep1, Rep2).

7
#

Returns: d * s.

template <class Rep1, class Period, class Rep2> constexpr duration<common_type_t<Rep1, Rep2>, Period> operator/(const duration<Rep1, Period>& d, const Rep2& s);

8
#

Remarks: Этот оператор не должен участвовать в разрешении перегрузки , если Rep2 не неявное преобразование CR(Rep1, Rep2) и Rep2 не является специализация duration.

9
#

Returns: CD(CD(d).count() / s).

template <class Rep1, class Period1, class Rep2, class Period2> constexpr common_type_t<Rep1, Rep2> operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

10
#

Returns: CD(lhs).count() / CD(rhs).count().

template <class Rep1, class Period, class Rep2> constexpr duration<common_type_t<Rep1, Rep2>, Period> operator%(const duration<Rep1, Period>& d, const Rep2& s);

11
#

Remarks: Этот оператор не должен участвовать в разрешении перегрузки , если Rep2 не неявное преобразование CR(Rep1, Rep2) и Rep2 не является специализация duration.

12
#

Returns: CD(CD(d).count() % s).

template <class Rep1, class Period1, class Rep2, class Period2> constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>> operator%(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

13
#

Returns: CD(CD(lhs).count() % CD(rhs).count()).

23.17.5.6 duration comparisons [time.duration.comparisons]

1
#

В нижеследующих описаниях функций, CT представляет common_­type_­t<A, B>, где A и B - типы двух аргументов функции.

template <class Rep1, class Period1, class Rep2, class Period2> constexpr bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

2
#

Returns: CT(lhs).count() == CT(rhs).count().

template <class Rep1, class Period1, class Rep2, class Period2> constexpr bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

3
#

Returns: !(lhs == rhs).

template <class Rep1, class Period1, class Rep2, class Period2> constexpr bool operator<(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

4
#

Returns: CT(lhs).count() < CT(rhs).count().

template <class Rep1, class Period1, class Rep2, class Period2> constexpr bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

5
#

Returns: !(rhs < lhs).

template <class Rep1, class Period1, class Rep2, class Period2> constexpr bool operator>(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

6
#

Returns: rhs < lhs.

template <class Rep1, class Period1, class Rep2, class Period2> constexpr bool operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);

7
#

Returns: !(lhs < rhs).

23.17.5.7 duration_­cast [time.duration.cast]

template <class ToDuration, class Rep, class Period> constexpr ToDuration duration_cast(const duration<Rep, Period>& d);

1
#

Remarks: Эта функция не должна участвовать в разрешении перегрузки, если ToDuration она не является специализацией duration.

2
#

Returns: Да CF будет ratio_­divide<Period, typename ToDuration​::​period>и CR будет common_­type< typename ToDuration​::​rep, Rep, intmax_­t>​::​type.

  • (2.1)

    Если CF​::​num == 1 и CF​::​den == 1, возвращает 

    ToDuration(static_cast<typename ToDuration::rep>(d.count()))
  • (2.2)

    в противном случае, если CF​::​num != 1 и CF​::​den == 1, возвращает 

    ToDuration(static_cast<typename ToDuration::rep>(
  static_cast<CR>(d.count()) * static_cast<CR>(CF::num)))
  • (2.3)

    в противном случае, если CF​::​num == 1 и CF​::​den != 1, возвращает 

    ToDuration(static_cast<typename ToDuration::rep>(
  static_cast<CR>(d.count()) / static_cast<CR>(CF::den)))
  • (2.4)

    в противном случае возвращается 

    ToDuration(static_cast<typename ToDuration::rep>(
  static_cast<CR>(d.count()) * static_cast<CR>(CF::num) / static_cast<CR>(CF::den)))
3
#

[  Note: Эта функция не использует никаких неявных преобразований; все преобразования выполняются с помощью static_­cast. Он избегает умножений и делений, когда во время компиляции известно, что один или несколько аргументов равны 1. Промежуточные вычисления выполняются в самом широком представлении и преобразуются в целевое представление только на последнем шаге. ]  — end note 

template <class ToDuration, class Rep, class Period> constexpr ToDuration floor(const duration<Rep, Period>& d);

4
#

Remarks: Эта функция не должна участвовать в разрешении перегрузки, если ToDuration она не является специализацией duration.

5
#

Returns: Наибольший результат, t представимый ToDuration для которого t <= d.

template <class ToDuration, class Rep, class Period> constexpr ToDuration ceil(const duration<Rep, Period>& d);

6
#

Remarks: Эта функция не должна участвовать в разрешении перегрузки, если ToDuration она не является специализацией duration.

7
#

Returns: Наименьший результат, t представимый ToDuration для которого t >= d.

template <class ToDuration, class Rep, class Period> constexpr ToDuration round(const duration<Rep, Period>& d);

8
#

Remarks: Эта функция не должна участвовать в разрешении перегрузки, если ToDuration она не является специализацией durationи не treat_­as_­floating_­point_­v<typename ToDuration​::​rep> является false.

9
#

Returns: Значение того, ToDuration что ближе всего к d. Если есть два ближайших значения, вернуть то значение, t для которого t % 2 == 0.

23.17.5.8 Suffixes for duration literals [time.duration.literals]

1
#

В этом разделе описаны буквальные суффиксы для построения литералов продолжительности. Суффиксы h, min, s, ms, us, ns обозначает значение длительности соответствующих типов hours, minutes, seconds, milliseconds, microseconds, и , nanoseconds соответственно , если они применяются к интегральным литералам.

2
#

Если любой из этих суффиксов применяется к литералу с плавающей запятой, результатом будет chrono​::​duration литерал с неопределенным представлением с плавающей запятой.

3
#

Если любой из этих суффиксов применяется к целочисленному литералу и результирующее chrono​::​duration значение не может быть представлено в типе результата из-за переполнения, программа имеет неправильный формат.

4
#

[  Example: В следующем коде показаны некоторые литералы продолжительности. 

using namespace std::chrono_literals;
auto constexpr aday=24h;
auto constexpr lesson=45min;
auto constexpr halfanhour=0.5h;

 — end example ]

constexpr chrono::hours operator""h(unsigned long long hours); constexpr chrono::duration<unspecified, ratio<3600, 1>> operator""h(long double hours);

5
#

Returns: duration Литерал hours часов.

constexpr chrono::minutes operator""min(unsigned long long minutes); constexpr chrono::duration<unspecified, ratio<60, 1>> operator""min(long double minutes);

6
#

Returns: duration Литерал minutes минут.

constexpr chrono::seconds operator""s(unsigned long long sec); constexpr chrono::duration<unspecified> operator""s(long double sec);

7
#

Returns: duration Литерал sec секунд.

8
#

[  Note: Используется тот же суффикс s , basic_­string но нет конфликта, поскольку суффиксы продолжительности применяются к числам, а суффиксы строковых литералов применяются к литералам символьных массивов. ]  — end note 

constexpr chrono::milliseconds operator""ms(unsigned long long msec); constexpr chrono::duration<unspecified, milli> operator""ms(long double msec);

9
#

Returns: duration Буквальный , представляющая msec миллисекунды.

constexpr chrono::microseconds operator""us(unsigned long long usec); constexpr chrono::duration<unspecified, micro> operator""us(long double usec);

10
#

Returns: duration Буквальный , представляющие usec микросекунды.

constexpr chrono::nanoseconds operator""ns(unsigned long long nsec); constexpr chrono::duration<unspecified, nano> operator""ns(long double nsec);

11
#

Returns: duration Буквальный , представляющие nsec наносекунды.

23.17.5.9 duration algorithms [time.duration.alg]

template <class Rep, class Period> constexpr duration<Rep, Period> abs(duration<Rep, Period> d);

1
#

Remarks: Эта функция не будет участвовать в разрешении перегрузки , если numeric_­limits<Rep>​::​is_­signed не true.

2
#

Returns: Если d >= d.zero()- вернуть d, в противном случае - вернуть -d.

23.17.6 Class template time_­point [time.point]

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+=(const duration& d);
  constexpr time_point& operator-=(const duration& d);

  // [time.point.special], special values
  static constexpr time_point min();
  static constexpr time_point max();
};
1
#

Clock должен соответствовать Clock requirements.

2
#

Если Duration не является экземпляром duration, программа имеет неверный формат .

23.17.6.1 time_­point constructors [time.point.cons]

constexpr time_point();

1
#

Effects: Создает объект типа time_­point, инициализируясь d_­ с помощью duration​::​zero(). Такой time_­point объект представляет эпоху.

constexpr explicit time_point(const duration& d);

2
#

Effects: Создает объект типа time_­point, инициализируясь d_­ с помощью d. Такой time_­point объект представляет эпоху + d.

template <class Duration2> constexpr time_point(const time_point<clock, Duration2>& t);

3
#

Remarks: Этот конструктор не должен участвовать в разрешении перегрузки, если он не Duration2 может быть неявно преобразован в duration.

4
#

Effects: Создает объект типа time_­point, инициализируясь d_­ с помощью t.time_­since_­epoch().

23.17.6.2 time_­point observer [time.point.observer]

constexpr duration time_since_epoch() const;

1
#

Returns: d_­.

23.17.6.3 time_­point arithmetic [time.point.arithmetic]

constexpr time_point& operator+=(const duration& d);

1
#

Effects: Как будто по: d_­ += d;

2
#

Returns: *this.

constexpr time_point& operator-=(const duration& d);

3
#

Effects: Как будто по: d_­ -= d;

4
#

Returns: *this.

23.17.6.4 time_­point special values [time.point.special]

static constexpr time_point min();

1
#

Returns: time_­point(duration​::​min()).

static constexpr time_point max();

2
#

Returns: time_­point(duration​::​max()).

23.17.6.5 time_­point 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), где CT - тип возвращаемого значения.

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), где CT - тип возвращаемого значения.

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

23.17.6.6 time_­point 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 == rhs).

template <class Clock, class Duration1, class Duration2> constexpr bool operator<(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);

3
#

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

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: rhs < lhs.

template <class Clock, class Duration1, class Duration2> constexpr bool operator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);

6
#

Returns: !(lhs < rhs).

23.17.6.7 time_­point_­cast [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
#

Remarks: Эта функция не должна участвовать в разрешении перегрузки, если ToDuration она не является специализацией 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
#

Remarks: Эта функция не должна участвовать в разрешении перегрузки, если ToDuration она не является специализацией 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
#

Remarks: Эта функция не должна участвовать в разрешении перегрузки, если ToDuration она не является специализацией 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
#

Remarks: Эта функция не должна участвовать в разрешении перегрузки, если ToDuration она не является специализацией durationи не treat_­as_­floating_­point_­v<typename ToDuration​::​rep> является false.

8
#

Returns: time_­point<Clock, ToDuration>(round<ToDuration>(tp.time_­since_­epoch())).

23.17.7 Clocks [time.clock]

1
#

Типы, определенные в этом подпункте, должны удовлетворять требованиям TrivialClock requirements.

23.17.7.1 Class system_­clock [time.clock.system]

1
#

Объекты класса system_­clock представляют время настенных часов из общесистемных часов реального времени.

class system_clock {
public:
  using rep        = see below;
  using period     = ratio<unspecified, unspecified>;
  using duration   = chrono::duration<rep, period>;
  using time_point = chrono::time_point<system_clock>;
  static constexpr bool is_steady = unspecified;

  static time_point now() noexcept;

  // Map to C API
  static time_t      to_time_t  (const time_point& t) noexcept;
  static time_point  from_time_t(time_t t) noexcept;
};

using system_clock::rep = unspecified;

2
#

Requires: system_­clock​::​duration​::​min() < system_­clock​::​duration​::​zero() будет true.
[  Note: Это означает, что rep это знаковый тип. ]  — end note 

static time_t to_time_t(const time_point& t) noexcept;

3
#

Returns: time_­t Объект , который представляет собой один и тот же момент времени , как , t когда оба значения ограничиваются грубее из точностей из time_­t и time_­point. Это определяется реализацией, округляются ли значения или усекаются до требуемой точности.

static time_point from_time_t(time_t t) noexcept;

4
#

Returns: time_­point Объект , который представляет собой один и тот же момент времени , как , t когда оба значения ограничиваются грубее из точностей из time_­t и time_­point. Это определяется реализацией, округляются ли значения или усекаются до требуемой точности.

23.17.7.2 Class steady_­clock [time.clock.steady]

1
#

Объекты класса steady_­clock представляют собой часы, для которых значения time_­point никогда не уменьшаются по мере продвижения физического времени и для которых значения time_­point продвигаются с постоянной скоростью относительно реального времени. То есть часы не могут быть настроены.

class steady_clock {
public:
  using rep        = unspecified;
  using period     = ratio<unspecified, unspecified>;
  using duration   = chrono::duration<rep, period>;
  using time_point = chrono::time_point<unspecified, duration>;
  static constexpr bool is_steady = true;

  static time_point now() noexcept;
};

23.17.7.3 Class high_­resolution_­clock [time.clock.hires]

1
#

Объекты класса high_­resolution_­clock представляют собой часы с самым коротким периодом тика. high_­resolution_­clock может быть синонимом system_­clock или steady_­clock.

class high_resolution_clock {
public:
  using rep        = unspecified;
  using period     = ratio<unspecified, unspecified>;
  using duration   = chrono::duration<rep, period>;
  using time_point = chrono::time_point<unspecified, duration>;
  static constexpr bool is_steady = unspecified;

  static time_point now() noexcept;
};

23.17.8 Header <ctime> synopsis [ctime.syn]

#define NULL see [support.types.nullptr]
#define CLOCKS_PER_SEC see below
#define TIME_UTC see below

namespace std {
  using size_t = see [support.types.layout];
  using clock_t = see below;
  using time_t = see below;

  struct timespec;
  struct tm;

  clock_t clock();
  double difftime(time_t time1, time_t time0);
  time_t mktime(struct tm* timeptr);
  time_t time(time_t* timer);
  int timespec_get(timespec* ts, int base);
  char* asctime(const struct tm* timeptr);
  char* ctime(const time_t* timer);
  struct tm* gmtime(const time_t* timer);
  struct tm* localtime(const time_t* timer);
  size_t strftime(char* s, size_t maxsize, const char* format, const struct tm* timeptr);
}
1
#

Содержимое заголовка <ctime> такие же , как заголовок стандартной библиотеки C <time.h>.223

2
#

Функции asctime, ctime, gmtimeи localtime не требуется avoid data races.

См. Также: ISO C 7.27.

223)

strftime поддерживает спецификаторов преобразования С C, D, e, F, g, G, h, r, R, t, T, u, V, и z, а также модификаторы E и O.