Карта сайта Kansoftware
НОВОСТИУСЛУГИРЕШЕНИЯКОНТАКТЫ
Разработка программного обеспечения

Reference

Boost , The Boost C++ Libraries BoostBook Documentation Subset , Chapter 7. Boost.Chrono 2.0.5

Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. — Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

PrevUpHomeNext
Header <boost/chrono/include.hpp>
Included on the C++11 Recommendation
Chrono I/O V1
Chrono I/O V2
Chrono Rounding Utilities
Other Clocks

Поскольку<constexpr>не поддерживается некоторыми компиляторами, он заменяется в коде на<BOOST_CONSTEXPR>для функций<constexpr>и<BOOST_STATIC_CONSTEXPR>для статических полей структуры/класса. То же самое относится и к<noexecpt>, который в коде заменяется<noexcept>.

Документация не использует эти макросы.

Включите все файлы заголовка chrono.

#include <boost/chrono/chrono.hpp>
#include <boost/chrono/chrono_io.hpp>
#include <boost/chrono/process_cpu_clocks.hpp>
#include <boost/chrono/thread_clocks.hpp>
#include <boost/chrono/ceil.hpp>
#include <boost/chrono/floor.hpp>
#include <boost/chrono/round.hpp>
Header <boost/chrono.hpp>
Header <boost/chrono/chrono.hpp>
Header <boost/chrono/duration.hpp>
Clock Requirements
TrivialClock Requirements
EcClock Requirements
Header <boost/chrono/time_point.hpp>
Header <boost/chrono/system_clocks.hpp>
Header <boost/chrono/clock_strings.hpp>
Header <boost/chrono/typeof/boost/chrono/chrono.hpp>

Включает только стандартные файлы.

#include <boost/chrono/chrono.hpp>
Limitations and Extensions
Configuration Macros

Включает только стандартные файлы.

#include <boost/chrono/duration.hpp>
#include <boost/chrono/time_point.hpp>
#include <boost/chrono/system_clocks.hpp>
#include <boost/chrono/typeof/boost/chrono/chrono.hpp>

В настоящее время нет никаких ограничений в отношении стандарта C++11.

Текущее осуществление предусматривает также:

Когда<BOOST_NO_CXX11_STATIC_ASSERT>определено, пользователь может выбрать способ сообщения статических утверждений. определять

  • <BOOST_CHRONO_USES_STATIC_ASSERT>: Определите, хотите ли вы использовать Boost. Статик-ассерт.
  • <BOOST_CHRONO_USES_MPL_ASSERT>: Определите его, если хотите использовать Boost. Статические утверждения MPL.
  • <BOOST_CHRONO_USES_ARRAY_ASSERT>: Определите его, если вы хотите использовать внутренние статические утверждения.

Поведение по умолчанию определяется как<BOOST_CHRONO_USES_ARRAY_ASSERT>.

Когда<BOOST_CHRONO_USES_MPL_ASSERT>не определено, следующие символы определяются как:

#define BOOST_CHRONO_A_DURATION_REPRESENTATION_CAN_NOT_BE_A_DURATION \
    "A duration representation can not be a duration"
#define BOOST_CHRONO_SECOND_TEMPLATE_PARAMETER_OF_DURATION_MUST_BE_A_STD_RATIO \
    "Second template parameter of duration must be a boost::ratio"
#define BOOST_CHRONO_DURATION_PERIOD_MUST_BE_POSITIVE \
    "duration period must be positive"
#define BOOST_CHRONO_SECOND_TEMPLATE_PARAMETER_OF_TIME_POINT_MUST_BE_A_BOOST_CHRONO_DURATION \
    "Second template parameter of time_point must be a boost::chrono::duration"

В зависимости от используемой системы статического утверждения у вас будет намек на неудачное утверждение либо через символ, либо через текст.

Когда<BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING>определено, lib не предоставляет прототипы гибридной обработки ошибок:

Clock::time_point Clock::now(system::error_code&ec=boost::throws());

Это позволяет приблизиться к стандарту и избежать повышения. Системная зависимость, позволяющая увеличить Хроно как библиотека только для заголовков.

По умолчанию<BOOST_CHRONO_PROVIDE_HYBRID_ERROR_HANDLING>определяется.

Когда<BOOST_CHRONO_HEADER_ONLY>определено, lib является только заголовком.

Если дополнительно<BOOST_USE_WINDOWS_H>определено<<windows.h>>включено, в противном случае файлы в<boost/detail/win>используются для уменьшения воздействия включения<<windows.h>>.

Однако вам нужно будет либо определить<BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING>, либо связать с Boost.System.

Версия 2.0.0 обесценивает предыдущие функции ввода-вывода.

Версия по умолчанию всегда является версией 1. Если вы не хотите включать устаревшие функции, вы можете определить<BOOST_CHRONO_DONT_PROVIDES_DEPRECATED_IO_SINCE_V2_0_0>.

<BOOST_CHRONO_VERSION>Определяет рост. Версия Хроно. Версия по умолчанию 1. В этом случае следующие макросы разрушения или расширения определяются, если не требуется обратное:

  • <BOOST_CHRONO_PROVIDES_DEPRECATED_IO_SINCE_V2_0_0>

Пользователь может запросить версию 2, определив<BOOST_CHRONO_VERSION>до 2. В этом случае следующие макросы разрушения или расширения определяются, если не требуется обратное:

  • Преодоление изменений<BOOST_CHRONO_DONT_PROVIDES_DEPRECATED_IO_SINCE_V2_0_0 >

Значение по умолчанию для<BOOST_CHRONO_VERSION>будет изменено на 2 с момента увеличения 1.55.

Time-related Traits
common_type Specialization
Class Template duration<>
duration Non-Member Arithmetic
duration Non-Member Comparaisons
Non-Member Function duration_cast(duration)
duration typedefs

Этот файл содержит конкретные классы продолжительности и функции, не являющиеся членами.

namespace boost {
  namespace chrono {
    template <class Rep, class Period = ratio<1> >  class duration;
  }
  template <class Rep1, class Period1, class Rep2, class Period2>
  struct common_type<duration<Rep1, Period1>,
                     duration<Rep2, Period2> >;
  namespace chrono {
    // customization traits
    template <class Rep> struct treat_as_floating_point;
    template <class Rep> struct duration_values;
    // duration arithmetic
    template <class Rep1, class Period1, class Rep2, class Period2>
    constexpr
    typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
    operator+(
        const duration<Rep1, Period1>& lhs,
        const duration<Rep2, Period2>& rhs);
    template <class Rep1, class Period1, class Rep2, class Period2>
    constexpr
    typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2> >::type
    operator-(
        const duration<Rep1, Period1>& lhs,
        const duration<Rep2, Period2>& rhs);
    template <class Rep1, class Period, class Rep2>
    constexpr
    duration<typename common_type<Rep1, Rep2>::type, Period>
    operator*(
        const duration<Rep1, Period>& d,
        const Rep2& s);
    template <class Rep1, class Period, class Rep2>
    constexpr
    duration<typename common_type<Rep1, Rep2>::type, Period>
    operator*(
        const Rep1& s,
        const duration<Rep2, Period>& d);
    template <class Rep1, class Period, class Rep2>
    constexpr
    duration<typename common_type<Rep1, Rep2>::type, Period>
    operator/(
        const duration<Rep1, Period>& d,
        const Rep2& s);
    template <class Rep1, class Period1, class Rep2, class Period2>
    constexpr
    typename common_type<Rep1, Rep2>::type
    operator/(
        const duration<Rep1, Period1>& lhs,
        const duration<Rep2, Period2>& rhs);
    #ifdef BOOST_CHRONO_EXTENSIONS
    // Used to get frequency of events
    template <class Rep1, class Rep2, class Period>
    constexpr
    double operator/(
        const Rep1& s,
        const duration<Rep2, Period>& d);
    #endif
    // 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 __duration__op_le_1(
        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);
    // duration_cast
    template <class ToDuration, class Rep, class Period>
    constexpr
    ToDuration duration_cast(const duration<Rep, Period>& d);
    // convenience typedefs
    typedef duration<boost::int_least64_t, nano> nanoseconds;    // at least 64 bits needed
    typedef duration<boost::int_least64_t, micro> microseconds;  // at least 55 bits needed
    typedef duration<boost::int_least64_t, milli> milliseconds;  // at least 45 bits needed
    typedef duration<boost::int_least64_t> seconds;              // at least 35 bits needed
    typedef duration<boost::int_least32_t, ratio< 60> > minutes; // at least 29 bits needed
    typedef duration<boost::int_least32_t, ratio<3600> > hours;  // at least 23 bits needed
  }
}

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

Шаблон<duration>использует<treat_as_floating_point>черту, чтобы помочь определить, может ли<duration>с одним периодом клеща быть преобразован в другой<duration>с другим периодом клеща. Если<treat_as_floating_point<Rep>::value><true>, то<Rep>является типом с плавающей точкой, и неявные преобразования допускаются среди<duration>с. В противном случае неявная конвертируемость зависит от периодов клещей<duration>с. Если<Rep>является типом класса, который эмулирует тип с плавающей точкой, автор<Rep>может специализироваться<treat_as_floating_point>, так что<duration>будет относиться к этому<Rep>как к типу с плавающей точкой. В противном случае<Rep>предполагается интегральным типом или классом, эмулирующим интегральный тип.

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

Шаблон<duration>использует<duration_values>черту для построения специальных значений представления<duration><Rep>. Это делается потому, что представление может быть типом класса с поведением, которое требует некоторой другой реализации, чтобы вернуть эти особые значения. В этом случае автор данного класса должен специализироваться<duration_values>для возврата указанных значений.

static constexpr Rep zero();

Возврат:<Rep(0)>.Примечание:<Rep(0)>указывается вместо<Rep()>, поскольку<Rep()>может иметь какое-то другое значение, такое как неинициализированное значение.

Замечания:Возвращенное значение соответствует аддитивной идентичности.

static constexpr Rep max();

Возвращение:<numeric_limits<Rep>::max()>.

Замечания:Возвратное значение больше нуля ().

static constexpr Rep min();

Возвращение:<numeric_limits<Rep>::lowest()>.

Замечания:Возвращаемое значение меньше или равно<zero()>.

template <class Rep1, class Period1, class Rep2, class Period2>
struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2> >
{
    typedef chrono::duration<typename common_type<Rep1, Rep2>::type, see bellow> type;
};

Период<duration>, обозначенный этой специализацией<common_type>, является наибольшим общим делителем<Period1>и<Period2>. Это можно вычислить, сформировав<ratio>наибольшего общего делителя<Period1::num>и<Period2::num>и наименьшего общего кратного<Period1::den>и<Period2::den>.

Примечание:Тип DEF является типом.<duration>с наибольшим возможным периодом клещей<duration>доводы преобразуются в него, не требуя операции деления. Представление этого типа предназначено для того, чтобы иметь возможность удерживать любое значение, возникающее в результате этого преобразования, за возможным исключением ошибки округления при задействовании плавающей точки<duration>(но не ошибки усечения).

A<duration>измеряет время между двумя точками во времени<time_point>. A<duration>имеет представление, которое содержит количество клещей и период клещей. Период клеща — это количество времени, которое происходит от одного клеща к другому в единицах секунды. Она выражается как рациональная константа с использованием<ratio>.

namespace boost { namespace chrono {
    template <class Rep, class Period>
    class duration {
    public:
        typedef Rep rep;
        typedef Period period;
    private:
        rep rep_; // exposition only
    public:
        constexpr duration();
        template <class Rep2>
        constexpr explicit duration(const Rep2& r);
        template <class Rep2, class Period2>
        constexpr duration(const duration<Rep2, Period2>& d);
        duration& operator=(const duration&) = default;
        constexpr rep count() const;
        constexpr duration  __duration__op_plus();
        constexpr duration  __duration__op_minus();
        duration& operator++();
        duration  operator++(int);
        duration& operator--();
        duration  operator--(int);
        duration& operator+=(const duration& d);
        duration& operator-=(const duration& d);
        duration& operator*=(const rep& rhs);
        duration& operator/=(const rep& rhs);
        duration& operator%=(const rep& rhs);
        duration& operator%=(const duration& rhs);
        static constexpr duration zero();
        static constexpr duration min();
        static constexpr duration max();
    };
}}

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

<Period>должен быть инстанциацией<ratio>, компилировать диагностику иначе.

<Period::num>должны быть положительными, иначе составляют диагностику.

Примеры:

  • <duration><длинный,<ratio><60>>имеет счет минут, используя длинный.
  • <duration><longlong,milli>проводит подсчет миллисекунд с использованием длинной длины.
  • <duration><двойной,<ratio><1,30>>проводит подсчет, используя двойной с периодом клеща 1/30 секунды (частота клеща 30 Гц).

Следующие члены<duration>не делают исключения, если указанные операции на представлениях не делают исключения.

constexpr duration();

<Rep2>неявно конвертируется в<rep>, и

  • <treat_as_floating_point<rep>::value>является<true>, или
  • <!treat_as_floating_point<rep>::value &&!treat_as_floating_point<Rep2>::value>является<true>.

Если эти ограничения не будут выполнены, этот конструктор не будет участвовать в разрешении перегрузки.Примечание:Это требование препятствует построению интегральной основы.<duration>с представлением с плавающей точкой. Такая конструкция может легко привести к путанице относительно стоимости<duration>.

Пример:

duration<int, milli> d(3.5);  // do not compile
duration<int, milli> d(3);    // ok

Условия поста:<count()==static_cast<rep>(r)>.

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

Замечания:<treat_as_floating_point<rep>::value>или<ratio_divide<Period2, period>::type::den== 1>, иначе этот конструктор не будет участвовать в разрешении перегрузки.примечаниеЭто требование предотвращает неявную ошибку усечения при преобразовании между интегральными<duration>с. Такая конструкция может легко привести к путанице относительно значения<duration>.

Пример:

duration<int, milli> ms(3);
duration<int, micro> us = ms;  // ok
duration<int, milli> ms2 = us; // do not compile

Возвращение:<rep_>.

constexpr duration operator+() const;

Возвращение:<*this>.

constexpr duration operator-() const;

Возвращается:<duration>[-.

duration& operator++();

Эффекты:<++rep_>.

Возвращение:<*this>.

duration operator++(int);

Возврат:<duration>rep_++].

duration& operator--();

Эффекты:<--rep_>.

Возвращение:<*this>.

duration operator--(int);

Возвращение:<duration>--].

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

Эффекты:<rep_ +=d.count()>.

Возвращение:<*this>.

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

Эффекты:<rep_ -=d.count()>.

Возвращение:<*this>.

duration& operator%=(const duration& d);

Эффекты:<rep_ %=d.count()>.

Возвращение:<*this>.

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

Эффекты:<rep_ *=rhs>.

Возвращение:<*this>.

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

Эффекты:<rep_ /=rhs>.

Возвращение:<*this>.

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

Эффекты:<rep_ %=rhs>.

Возвращение:<*this>.

static constexpr duration zero();

Возвращение:<duration><duration_values><>::ноль()].

static constexpr duration min();

Возвращение:<duration><duration_values><>::мин()]

static constexpr duration max();

Возвращается:<duration><duration_values><>::max()).

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

456Возврат:<CD(CD(lhs).count()+CD(rhs).count())>, где<CD>является типом возвращаемого значения.

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

Возврат:<CD(CD(lhs).count()-CD(rhs).count())>, где<CD>является типом возвращаемого значения.

template <class Rep1, class Period, class Rep2>
constexpr
duration<typename common_type<Rep1, Rep2>::type, Period>
operator*(const duration<Rep1, Period>& d, const Rep2& s);

Пусть<CR>представляет<common_type><Rep1>и<Rep2>. Эта функция не будет участвовать в разрешении перегрузки, если и<Rep1>, и<Rep2>не являются неявно конвертируемыми в<CR>.

Возврат:<CD(CD(d).count()*s)>, где<CD>является типом возвращаемого значения.

template <class Rep1, class Period, class Rep2>
constexpr
duration<typename common_type<Rep1, Rep2>::type, Period>
operator*(const Rep1& s, const duration<Rep2, Period>& d);

Пусть<CR>представляет<common_type><Rep1>и<Rep2>. Эта функция не будет участвовать в разрешении перегрузки, если и<Rep1>, и<Rep2>не являются неявно конвертируемыми в<CR>.

Возвращение:<d *s>.

template <class Rep1, class Period, class Rep2>
constexpr
duration<typename common_type<Rep1, Rep2>::type, Period>
operator/(const duration<Rep1, Period>& d, const Rep2& s);

Требует:Пусть<CR>представляет<common_type><Rep1>и<Rep2>. Эта функция не будет участвовать в разрешении перегрузки, если и<Rep1>, и<Rep2>не являются неявно конвертируемыми в<CR>, и<Rep2>не является инстанциацией<duration>.

Возврат:<CD(CD(d).count()/s)>, где<CD>является типом возвращаемого значения.

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

Замечания:Пусть<CD>представляет<common_type>из двух<duration>аргументы.Возвращение:Возвращение<CD(lhs).count()/CD(rhs).count()>.

Включается только при определении BOOST_CHRONO_EXTENSIONS.

Эта перегрузка может быть использована для подсчета частоты события<Rep1>.

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

Замечания:Пусть<CR>представляет<common_type><Rep1>и<Rep2>. Эта функция не будет участвовать в разрешении перегрузки, если и<Rep1>, и<Rep2>не являются неявно конвертируемыми в<CR>, и<Rep1>не является инстанциацией<duration>. Пусть<CD>представляют<duration>.

Возврат:<CR(s)/CD(d).count()>, где<CD>является типом возвращаемого значения.

template <class Rep1, class Period, class Rep2>
constexpr
duration<typename common_type<Rep1, Rep2>::type, Period>
operator%(const duration<Rep1, Period>& d, const Rep2& s);

Замечания:Пусть<CR>представляет<common_type><Rep1>и<Rep2>. Эта функция не будет участвовать в разрешении перегрузки, если Rep2 не должен быть неявно конвертируемым в CR, а Rep2 не должен быть инстанциацией<duration>.

Возврат:CD(CD(d.count()% s), где<CD>является типом возвращаемого значения.

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

Замечания:Эта функция не будет участвовать в разрешении перегрузки, если только

Возврат:CD(CD(lhs.count) % CD(rhs.count()), где<CD>является типом возвращаемого значения.

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

Возвращение:Пусть<CD>представляет<common_type>из двух<duration>аргументов.

Возвращение:Возвращение<CD(lhs).count()==CD(rhs).count()>

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

Возвращение:<!(lhs== rhs)>.

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

Возвращение:Пусть<CD>представляют<common_type>из двух<duration>аргументов. Возвращение<CD(lhs).count() <CD(rhs).count()>

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

Возвращение:<!(rhs< lhs)>.

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

Возвращение:<rhs <lhs>.

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

Возвращение:<!(lhs< rhs)>.

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

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

Возвращение:Формы<CF>, которые являются<ratio>результатом<ratio_divide<Period,typenameToDuration::period>::type>. Пусть<CR>будет<common_type>из<ToDuration::rep>,<Rep>и<intmax_t>.

  • Если<CF::num== 1>и<CF::den ==1>, то возвращается<ToDuration(static_cast<typename ToDuration::rep>(d.count())) >.
  • Если же<CF::num!= 1>и<CF::den ==1>, то возвращается<ToDuration(static_cast<typename ToDuration::rep>(static_cast<CR>(d.count()) *static_cast<CR>(CF::num)))>.
  • Если же<CF::num== 1>и<CF::den !=1>, то возвращается<ToDuration(static_cast<typename ToDuration::rep>(static_cast<CR>(d.count()) /static_cast<CR>(CF::den)))>.
  • Возвращение<ToDuration(static_cast<typename ToDuration::rep>(static_cast<CR>(d.count()) *static_cast<CR>(CF::num)/static_cast<CR>(CF::den)))>

Замечания:Эта функция не зависит от неявных конверсий. Все преобразования должны осуществляться через<static_cast>. Реализация позволяет избежать всех умножений или делений, когда на этапе компиляции известно, что этого можно избежать, поскольку один или несколько аргументов являются<1>. Все промежуточные вычисления выполняются в максимально широком представлении и преобразуются в представление назначения только на заключительном этапе.

// convenience typedefs
typedef duration<boost::int_least64_t, nano> nanoseconds;    // at least 64 bits needed
typedef duration<boost::int_least64_t, micro> microseconds;  // at least 55 bits needed
typedef duration<boost::int_least64_t, milli> milliseconds;  // at least 45 bits needed
typedef duration<boost::int_least64_t> seconds;              // at least 35 bits needed
typedef duration<boost::int_least32_t, ratio< 60> > minutes; // at least 29 bits needed
typedef duration<boost::int_least32_t, ratio<3600> > hours;  // at least 23 bits needed

Часы представляют собой пучок, состоящий из<duration>,<time_point>и функции<now()>для получения тока<time_point>. Часы должны соответствовать требованиям следующей таблицы.

В этой таблице<C1>и<C2>обозначают<Clock>типы.<t1>и<t2>являются значениями, возвращенными из<C1::now()>, где возврат вызова<t1>происходит до возврата вызова<t2>, и оба этих вызова происходят до<C1::time_point::max()>. примечание Это означает, что C1 не оборачивается между t1 и t2.

Table 7.1. Clock Requirements

выражение

Тип возврата

Оперативная семантика

<C1::rep>

Арифметический тип или класс, имитирующий арифметический тип.

Тип представления<duration>и<time_point>

.

<C1::period>

<ratio>

Период тика часов в секундах.

<C1::duration>

<chrono::duration<C1::rep, C1::period>>

<duration>Тип<clock>

.

<C1::time_point>

<chrono::time_point<C1> orchrono::time_point<C2,C1::duration>>

<time_point>тип<clock>. Разные часы могут иметь общее определение<time_point>, если допустимо сравнивать их точки времени, сравнивая их соответствующие<duration>с.<C1>и<C2>должны относиться к одной и той же эпохе.

<C1::is_steady>

<constexprbool>

<true>, если<t1<= t2>всегда<true>, иначе<false>.Примечание:<clock>, который может быть отрегулирован назад, не является устойчивым

<C1::now()>

<C1::time_point>

Возвращает<time_point>, представляющий текущий момент времени.

Модели<Clock>:

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

  • <TC>удовлетворяет требованиям<Clock>,
  • Типы<TC::rep>,<TC::duration>и<TC::time_point>удовлетворяют требованиям<EqualityComparable>,<LessThanComparable>,<DefaultConstructible>,<CopyConstructible>,<CopyAssignable>,<Destructible>и требованиям числовых типов.
[Note] Note

Это означает, в частности, что операции на этих типах не будут бросать исключений.

  • l значения типов<TC::rep>,<TC::duration>и<TC::time_point>являются сменными,
  • Функция<TC::now()>не бросает исключений и она безвредна для потока, и
  • Тип<TC::time_point::clock>отвечает требованиям<TrivialClock>рекурсивно.

<TrivialClock>:

Тип<EcC>соответствует требованиям<EcClock>, если

  • <TC>удовлетворяет требованиям<TrivialClock>, и
  • Он добавляет<now()>интерфейсы, позволяющие восстанавливать внутренние коды ошибок, как описано в следующей таблице.
  • Добавленная функция сейчас() безвредна.

В этой таблице<C1>обозначает тип<EcClock>и<ec>является примером<boost::system::error_code>.

Table 7.2. Clock Requirements

выражение

Тип возврата

Оперативная семантика

<C1::now(ec)>

<C1::time_point>

Возвращает<time_point>, представляющий текущий момент времени.<ec>будет хранить код ошибки в случае, если что-то не так внутри.

<C1::now(boost::throws())>

<C1::time_point>

Возвращает<time_point>, представляющий текущий момент времени. Исключение составляет<boost::system::system_error>, если что-то не так внутри.

Модели<Clock>:

common_type specialization
Class template time_point<>
time_point non-member arithmetic
time_point non-member comparisons
Non-Member Function time_point_cast(time_point)

Этот файл содержит<time_point>конкретные классы и нечленные функции.

namespace boost {
  namespace chrono {
    template <class Clock, class Duration = typename Clock::duration>
    class time_point;
  }
  template <class Clock, class Duration1, class Duration2>
  struct common_type<time_point<Clock, Duration1>,
                     time_point<Clock, Duration2> >;
  namespace chrono {
    // time_point arithmetic
    template <class Clock, class Duration1, class Rep2, class Period2>
    constexpr time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2> >::type>
    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, typename common_type<duration<Rep1, Period1>, Duration2>::type>
    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, typename common_type<Duration1, duration<Rep2, Period2> >::type>
    operator-(const time_point<Clock, Duration1>& lhs,
              const duration<Rep2, Period2>& rhs);
    template <class Clock, class Duration1, class Duration2>
    constexpr typename common_type<Duration1, Duration2>::type
    operator-(const time_point<Clock, Duration1>& lhs,
              const time_point<Clock, Duration2>& rhs);
    // 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
    template <class ToDuration, class Clock, class Duration>
    constexpr time_point<Clock, ToDuration>
    time_point_cast(const time_point<Clock, Duration>& t);
  }
}

template <class Clock, class Duration1, class Duration2>
struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2> >
{
    typedef chrono::time_point<Clock, typename common_type<Duration1, Duration2>::type> type;
};

<common_type>из двух<time_point>с является<time_point>с тем же<Clock>(оба имеют тот же<Clock>), и<common_type>из двух<duration>с.

<time_point>представляет собой точку во времени относительно конкретных часов.

template <class Clock, class Duration>
class time_point {
public:
    typedef Clock                     clock;
    typedef Duration                  duration;
    typedef typename duration::rep    rep;
    typedef typename duration::period period;
private:
    duration d_; // exposition only
public:
    constexpr time_point();
    constexpr explicit time_point(const duration& d);
    // conversions
    template <class Duration2>
    constexpr
    time_point(const time_point<clock, Duration2>& t);
    // observer
    constexpr duration time_since_epoch() const;
    // arithmetic
    #ifdef BOOST_CHRONO_EXTENSIONS
    constexpr time_point  operator+();
    constexpr time_point  operator-();
    time_point& operator++();
    time_point  operator++(int);
    time_point& operator--();
    time_point  operator--(int);
    time_point& __time_point__op_plus_eq_1(const rep& d);
    time_point& operator-=(const rep& d);
    #endif
    time_point& __time_point__op_plus_eq_2(const duration& d);
    time_point& operator-=(const duration& d);
    // special values
    static constexpr time_point min();
    static constexpr time_point max();
};

Часы должны соответствовать требованиям<Clock>.

Продолжительность должна быть инстанциацией<duration>, компилировать диагностику иначе.

constexpr time_point();

Эффекты:Построение объекта<time_point>, инициализация<d_>с<duration::zero()>. Это<time_point>представляет эпоху.

constexpr time_point(const duration& d);

Эффекты:Построение объекта<time_point>, инициализация<d_>с<d>. Это<time_point>представляет эпоху<+d>.

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

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

Эффекты:Построение объекта<time_point>, инициализация<d_>с<t.time_since_epoch()>.

constexpr duration time_since_epoch() const;

Возвращение:<d_>.

constexpr time_point operator+() const;

Возвращение:<*this>.

constexpr time_point operator-() const;

Возвращение:<time_point>[-d_.

time_point& operator++();

Эффекты:<++d_>.

Возвращение:<*this>.

time_point operator++(int);

Возвращается:<time_point>d_++].

time_point& operator--();

Эффекты:<--d_>.

Возвращение:<*this>.

time_point operator--(int);

Возвращение:<time_point>d_--].

time_point& operator+=(const rep& r);

Эффекты:<d_ +=duration(r)>.

Возвращение:<*this>.

time_point& operator-=(const rep& r);

Эффекты:<d_ -=duration(r)>

Возвращение:<*this>.

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

Эффекты:<d_ +=d>.

Возвращение:<*this>.

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

Эффекты:<d_ -=d>

Возвращение:<*this>.

static constexpr time_point min();

Возвращение:<time_point(duration::min())>.

static constexpr time_point max();

Возвращение:<time_point(duration::max())>.

template <class Clock, class Duration1, class Rep2, class Period2>
constexpr
time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2> >::type>
operator+(const time_point<Clock, Duration1>& lhs,
          const duration<Rep2, Period2>& rhs);

Возврат:<CT(lhs.time_since_epoch()+rhs)>, где<CT>является типом возвращаемого значения.

template <class Rep1, class Period1, class Clock, class Duration2>
constexpr
time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::type>
operator+(const duration<Rep1, Period1>& lhs,
          const time_point<Clock, Duration2>& rhs);

Возвращение:<rhs +lhs>.

template <class Clock, class Duration1, class Rep2, class Period2>
constexpr
time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2> >::type>
operator-(const time_point<Clock, Duration1>& lhs,
          const duration<Rep2, Period2>& rhs);

Возвращение:<lhs +(-rhs)>.

template <class Clock, class Duration1, class Duration2>
constexpr
typename common_type<Duration1, Duration2>::type
operator-(const time_point<Clock, Duration1>& lhs,
          const time_point<Clock, Duration2>& rhs);

Возвращение:<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);

Возвращение:<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);

Возвращение:<!(lhs== rhs)>.

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

1116Возврат: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);

Возвращение:<!(rhs< lhs)>.

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

Возвращение:<rhs <lhs>.

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

Возвращение:<!(lhs< rhs)>.

template <class ToDuration, class Clock, class Duration>
constexpr
time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);

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

1146Возвращается:<time_point><<Clock>,ToDuration><duration_cast><ToDuration>t.time_since_epoch[)].

Class system_clock
Macro BOOST_CHRONO_HAS_CLOCK_STEADY
Class steady_clock
Class high_resolution_clock
clock_string<system_clock> Specialization
clock_string<steady_clock> Specialization

Этот файл содержит стандартные классы часов. Типы, определенные в этом разделе, удовлетворяют требованиям<TrivialClock>.

namespace boost {
  namespace chrono {
    // Clocks
    class system_clock;
    class steady_clock;
    class high_resolution_clock;
    template <class CharT>
    struct clock_string<system_clock, CharT>;
    template <class CharT>
    struct clock_string<steady_clock, CharT>;
  }
}

Класс<system_clock>обеспечивает способ получения текущего времени настенных часов от общесистемных часов реального времени. Текущее время можно получить по телефону<system_clock::now()>. Случаи<system_clock::time_point>могут быть преобразованы в функции<system_clock::to_time_t()>и<system_clock::from_time_t()>и из них. Если системные часы нестабильны, последующий вызов<system_clock::now()>может вернуть более раннее время, чем предыдущий вызов (например, если часы операционной системы настроены вручную или синхронизированы с внешними часами).

Нынешняя реализация<system_clock>связана с эпохой (полночь UTC 1 января 1970 года), но это не входит в контракт. Вы должны использовать статическую функцию статического

std::time_t to_time_t(const time_point& t);

Тип 1192, основанный на полночь UTC 1 января 1970 года.

class system_clock {
public:
    typedef see bellow          duration;
    typedef duration::rep                        rep;
    typedef duration::period                     period;
    typedef chrono::time_point<system_clock>     time_point;
    static constexpr bool is_steady =            false;
    static time_point  now() noexcept;
    static time_point  now(system::error_code & ec);
    // Map to C API
    static std::time_t to_time_t(const time_point& t) noexcept;
    static time_point  from_time_t(std::time_t t) noexcept;
};

<system_clock>удовлетворяют требованиям<Clock>:

  • <system_clock::duration::min() <system_clock::duration::zero()>—<true>.
  • Вложенный<duration>типдеф имеет разрешение, зависящее от того, которое обеспечивает платформа.
time_t to_time_t(const time_point& t) noexcept;

Возвращает:А<time_t>так, что<time_t>и<t>представляют собой один и тот же момент времени, усеченный до более грубой точности среди<time_t>и<time_point>.

time_point from_time_t(time_t t) noexcept;

Возвращается:А<time_point>так, что<time_point>и<t>представляют один и тот же момент времени, усеченный до более грубой точности среди<time_point>и<time_t>.

Определено, поддерживает ли платформа устойчивые часы.

<steady_clock>удовлетворяют требованиям<Clock>.

<steady_clock>класс обеспечивает доступ к системным устойчивым часам. Текущее время можно получить по телефону<steady_clock::now()>. Не существует фиксированной связи между значениями, возвращаемыми<steady_clock::now()>и временем настенных часов.

#ifdef BOOST_HAS_CLOCK_STEADY
    class steady_clock {
    public:
        typedef nanoseconds                          duration;
        typedef duration::rep                        rep;
        typedef duration::period                     period;
        typedef chrono::time_point<steady_clock>     time_point;
        static constexpr bool is_steady =            true;
        static time_point  now() noexcept;
        static time_point  now(system::error_code & ec);
    };
#endif

<high_resolution_clock>удовлетворяют требованиям<Clock>.

#ifdef BOOST_CHRONO_HAS_CLOCK_STEADY
  typedef steady_clock high_resolution_clock;  // as permitted by [time.clock.hires]
#else
  typedef system_clock high_resolution_clock;  // as permitted by [time.clock.hires]
#endif

template <class CharT>
struct clock_string<system_clock, CharT>
{
    static std::basic_string<CharT> name();
    static std::basic_string<CharT> since();
};

<clock_string<>::name()>возвращает «system_clock».

<clock_string<>::since()>Возвращение «с 1 января 1970 года»

#ifdef BOOST_CHRONO_HAS_CLOCK_STEADY
template <class CharT>
struct clock_string<steady_clock, CharT>
{
    static std::basic_string<CharT> name();
    static std::basic_string<CharT> since();
};
#endif

<clock_string<>::name()>возвращает «steady_clock».

<clock_string<>::since()>Возвращение «с ботинка»

Template Class clock_string<>
namespace boost {
  namespace chrono {
    template <class Clock, class CharT>
    struct clock_string;
  }
}

template <class Clock, class CharT>
struct clock_string;

Этот шаблон должен быть специализирован для конкретных часов. Специализация должна определять следующие функции:

static std::basic_string<CharT> name();
static std::basic_string<CharT> since();

<clock_string<>::name()>Возвращают название часов, которое обычно соответствует названию класса.

<clock_string<>::since()>Возвращение текстового формата эпохи часов.

Зарегистрируйте<duration><<>>и<time_point><<>>шаблоны классовBoost.Typeof.

Header <boost/chrono/chrono_io.hpp>
Template Class duration_punct<>
I/O Manipulators
I/O Streams Operations
namespace boost {
namespace chrono {
    template <class CharT>
    class duration_punct;
    template <class CharT, class Traits>
        std::basic_ostream<CharT, Traits>&
        duration_short(std::basic_ostream<CharT, Traits>& os);
    template <class CharT, class Traits>
        std::basic_ostream<CharT, Traits>&
        duration_long(std::basic_ostream<CharT, Traits>& os);
    template <class CharT, class Traits, class Rep, class Period>
        std::basic_ostream<CharT, Traits>&
        operator<<(std::basic_ostream<CharT, Traits>& os, const duration<Rep, Period>& d);
    template <class CharT, class Traits, class Rep, class Period>
        std::basic_istream<CharT, Traits>&
        operator>>(std::basic_istream<CharT, Traits>& is, duration<Rep, Period>& d)
    template <class CharT, class Traits, class Clock, class Duration>
        std::basic_ostream<CharT, Traits>&
        operator<<(std::basic_ostream<CharT, Traits>& os,
               const time_point<Clock, Duration>& tp);
    template <class CharT, class Traits, class Clock, class Duration>
        std::basic_istream<CharT, Traits>&
        operator>>(std::basic_istream<CharT, Traits>& is,
               time_point<Clock, Duration>& tp);
}
}

Названия единиц<duration>могут быть настроены через грань:<duration_punct>.<duration>наименования единиц бывают двух разновидностей: длинные и короткие. По умолчанию построенный<duration_punct>предоставляет имена в длинном формате. Эти названия являются английскими описаниями. Другие языки поддерживаются построением<duration_punct>с правильными написаниями для «часов», «минут» и «секунд», а также их сокращениями (для короткого формата).

template <class CharT>
class duration_punct
    : public std::locale::facet
{
public:
    typedef std::basic_string<CharT> string_type;
    enum {use_long, use_short};
    static std::locale::id id;
    explicit duration_punct(int use = use_long);
    duration_punct(int use,
        const string_type& long_seconds, const string_type& long_minutes,
        const string_type& long_hours, const string_type& short_seconds,
        const string_type& short_minutes, const string_type& short_hours);
    duration_punct(int use, const duration_punct& d);
    template <class Period> string_type short_name() const;
    template <class Period> string_type long_name() const;
    template <class Period> string_type name() const;
    bool is_short_name() const;
    bool is_long_name() const;
};

Короткий или длинный формат может быть легко выбран путем потоковой передачи манипулятора<duration_short>или<duration_long>соответственно.

template <class CharT, class Traits>
    std::basic_ostream<CharT, Traits>&
    duration_short(std::basic_ostream<CharT, Traits>& os);

Эффекты:Установите грань<duration_punct>для потока<duration>и<time_point>в качестве сокращений.

Возврат:выходной поток

template <class CharT, class Traits>
    std::basic_ostream<CharT, Traits>&
    duration_long(std::basic_ostream<CharT, Traits>& os);

Эффекты:Установите грань<duration_punct>для потоковой передачи длительностей и точек времени в виде длинного текста.

Возврат:выходной поток

Любое<duration>может быть передано<basic_ostream>. Значение времени выполнения<duration>отформатировано в соответствии с правилами и текущими настройками формата для<duration><::rep>. За этим следует одно пространство, а затем имя единицы времени компиляции<duration>. Название этого блока построено на строке, возвращенной из<ratio_string<>>, и данных, используемых для построения<duration_punct>, которые были вставлены в местоположение потока. Если<duration_punct>не вставлено в локацию потока, в локацию потока будет добавлено построенное по умолчанию<duration_punct>.

А<time_point>форматируется путем вывода его внутреннего<duration>, за которым следует строка, описывающая<time_point><::clock>эпоху. Эта строка будет варьироваться для каждого отдельного часа и для каждой реализации поставляемых часов.

template <class CharT, class Traits, class Rep, class Period>
    std::basic_ostream<CharT, Traits>&
    operator<<(std::basic_ostream<CharT, Traits>& os, const duration<Rep, Period>& d);

Эффекты:выводит<duration>в виде сокращенного или длинного текстового формата в зависимости от состояния<duration_punct>грани.

Возврат:выходной поток

template <class CharT, class Traits, class Rep, class Period>
    std::basic_istream<CharT, Traits>&
    operator>>(std::basic_istream<CharT, Traits>& is, duration<Rep, Period>& d)

Эффекты:читает<duration>из входного потока. Если найдена ошибка формата, состояние входного потока будет установлено на<failbit>.

Возврат:входной поток

template <class CharT, class Traits, class Clock, class Duration>
    std::basic_ostream<CharT, Traits>&
    operator<<(std::basic_ostream<CharT, Traits>& os,
           const time_point<Clock, Duration>& tp);

Эффекты:выводит<time_point>в виде сокращенного или длинного текстового формата в зависимости от состояния<duration_punct>грани.

Возврат:выходной поток

template <class CharT, class Traits, class Clock, class Duration>
    std::basic_istream<CharT, Traits>&
    operator>>(std::basic_istream<CharT, Traits>& is,
           time_point<Clock, Duration>& tp);

Эффекты:читает<time_point>из входного потока. Если обнаружена ошибка формата, состояние потока ввода будет установлено на<failbit>.

Возврат:входной поток

Header <boost/chrono/chrono_io.hpp>
Header <boost/chrono/io/duration_style.hpp>
Header <boost/chrono/io/timezone.hpp>
Header <boost/chrono/io/ios_base_state.hpp>
Header <boost/chrono/io/duration_get.hpp>
Header <boost/chrono/io/duration_put.hpp>
Header <boost/chrono/io/duration_units.hpp>
Header <boost/chrono/io/duration_io.hpp>
Header <boost/chrono/io/time_point_get.hpp>
Header <boost/chrono/io/time_point_put.hpp>
Header <boost/chrono/io/time_point_units.hpp>
Header <boost/chrono/io/time_point_io.hpp>

Этот файл включает в себя i/o двух основных компонентов, длительность и точку времени.

#include <boost/chrono/io/duration_style.hpp>
#include <boost/chrono/io/timezone.hpp>
#include <boost/chrono/io/ios_base_state.hpp>
#include <boost/chrono/io/duration_get.hpp>
#include <boost/chrono/io/duration_put.hpp>
#include <boost/chrono/io/duration_units.hpp>
#include <boost/chrono/io/duration_io.hpp>
#include <boost/chrono/io/time_point_get.hpp>
#include <boost/chrono/io/time_point_put.hpp>
#include <boost/chrono/io/time_point_units.hpp>
#include <boost/chrono/io/time_point_io.hpp>
Scoped enum duration_style
namespace boost {
  namespace chrono {
    // typedefs
    enum class duration_style {
      prefix, symbol
    };
  }
}

enum class duration_style {
  prefix, symbol
};

<duration>названия единиц бывают двух разновидностей: префикс и символ.

Scoped enum timezone
namespace boost {
  namespace chrono {
    struct timezone
    {
      enum type {
        utc, local
      };
    };
  }
}

enum class timezone {
  utc, local
};
Setter and getters
I/O State Savers
namespace boost {
  namespace chrono {
    // setters and getters
    duration_style get_duration_style(std::ios_base & ios);
    void set_duration_style(std::ios_base& ios, duration_style style);
    timezone get_timezone(std::ios_base & ios);
    void set_timezone(std::ios_base& ios, timezone tz);
    template<typename CharT>
    std::basic_string<CharT> get_time_fmt(std::ios_base & ios);
    template<typename CharT>
    void set_time_fmt(std::ios_base& ios, std::basic_string<CharT> const& fmt);
    // i/o state savers
    struct duration_style_io_saver;
    template<typename CharT = char, typename Traits = std::char_traits<CharT> >
    struct timezone_io_saver;
    template<typename CharT = char, typename Traits = std::char_traits<CharT> >
    struct time_fmt_io_saver;
  }
}

duration_style get_duration_style(std::ios_base & ios);

Возвращение:<duration_style>атрибут, связанный с<ios>.

void set_duration_style(std::ios_base& ios, duration_style style);

Эффекты:Установите атрибут потока<duration_style>, связанный с<ios>параметром<style>.

timezone get_timezone(std::ios_base & ios);

Возвращение:<timezone>атрибут, связанный с<ios>.

void set_timezone(std::ios_base& ios, timezone tz);

Эффекты:Установите атрибут потока<timezone>, связанный с<ios>параметром<tz>.

template<typename CharT>
std::basic_string<CharT> get_time_fmt(std::ios_base & ios);

Возвращение:Атрибут формата времени потока, связанный с<ios>.

template<typename CharT>
void set_time_fmt(std::ios_base& ios, std::basic_string<CharT> const& fmt);

Эффекты:Установите атрибут формата времени потока, связанный с<ios>параметром<fmt>.

Формат состоит из нулевых или более директив. Каждая директива состоит из одного из следующих:

* one or more white-space characters (as specified by isspace());
* an ordinary character (neither '%' nor a white-space character);
* or a conversion specification.

Каждая спецификация преобразования состоит из символа «%», за которым следует символ преобразования, который определяет требуемую замену. Приложение должно обеспечивать наличие белого пространства или других буквенно-цифровых знаков между любыми двумя спецификациями преобразования. Поддерживаются следующие спецификации конверсии:

Table 7.3. Format tags

Спецификатор формата

Описание

Пример

<%%>

Заменил<%>

.

<%a %A>

День недели с использованием названий будни города; может быть указано сокращенное или полное название.

«Понедельник».

<%b %B %h>

Месяц с использованием названий месяца местности; может быть указано сокращенное или полное название.

«Февраль».

<%c>

Не поддерживается.

<%d %e>

День месяца<[01,31]>; ведущие нули разрешены, но не требуются.

<%D>

Дата:<%m/%d/%y>

<%F>

Дата:<%Y/%m/%d>

<%H>

Час (24 часа)<[00,23]>; ведущие нули разрешены, но не требуются.

<%I>

Час (12-часовые часы)<[01,12]>; ведущие нули разрешены, но не требуются.

<%j>

Число дней в году<[001,366]>; ведущие нули разрешены, но не требуются.

«060» =>29 февраля

<%m>

Номер месяца<[01,12]>; ведущие нули разрешены, но не требуются.

«01» =>январь.

<%M>

Минута<[00,59]>; ведущие нули разрешены, но не требуются.

<%n %t>

Любое белое пространство

<%p>

Не поддерживается.

<%r>

Не поддерживается.

<%R>

Время как<%H:%M>

<%S>

Секунды<[00,60]>; ведущие нули разрешены, но не требуются.

<%T>

Время как<%H:%M:%S>

<%U>

Не поддерживается.

<%w>

Дневной день как десятичное число<[0,6]>с 0, представляющим воскресенье; ведущие нули разрешены, но не требуются.

«0» =>Воскресенье.

<%W>

Не поддерживается.

<%x>

Дата, используя формат даты местности.

<%X>

Не поддерживается.

<%y>

Не поддерживается.

«2005».

<%Y>

Год, включая век (например, 1988).

 


// i/o state savers
struct duration_style_io_saver
{
  typedef std::ios_base state_type; // the state type is ios_base
  typedef duration_style aspect_type; // the aspect type is the __duration_style
  explicit duration_style_io_saver(state_type &s);
  duration_style_io_saver(state_type &s, aspect_type new_value);
  ~duration_style_io_saver();
  void restore();
};

<state_type>— версия базового класса IOStreams<std::ios_base>.

Этот конструктор берет объект потока и сохраняет ссылку на поток и текущее значение конкретного атрибута потока.

explicit duration_style_io_saver(state_type &s);

Эффекты:Конструирует<duration_style_io_saver>путем хранения<s>.

Этот конструктор работает так же, как предыдущий, и, кроме того, использует свой второй аргумент, чтобы изменить атрибут потока на новое значение<aspect_type>.

explicit duration_style_io_saver(state_type &s, aspect_type new_value);

Эффекты:Конструирует<duration_style_io_saver>путем хранения<s>. Устанавливает<state_type><aspect_type>со значением<new_value>.

Деструктор восстанавливает атрибут потока к сохраненному значению.

~duration_style_io_saver();

Эффекты:Как будто<restore>().

Восстановление может быть активировано рано (и часто) с помощью функции восстановления.

void restore();

Эффекты:Восстанавливает атрибут потока<duration_style>к сохраненному значению.

template<typename CharT = char, typename Traits = std::char_traits<CharT> >
struct timezone_io_saver
{
  typedef std::basic_ios<CharT, Traits> state_type;
  typedef timezone aspect_type;
  explicit timezone_io_saver(state_type &s);
  timezone_io_saver(state_type &s, aspect_type new_value);
  ~timezone_io_saver();
  void timezone_io_saver__restore();
};

<state_type>является версией шаблона базового класса IOStreams<std::basic_ios<CharT,Traits>>, где<CharT>является типом персонажа и<Traits>является классом признаков персонажа. Пользователь обычно размещает фактический объект ввода, вывода или комбинированного потока для параметра типа состояния, а не объект базового класса.

Этот конструктор берет объект потока и сохраняет ссылку на поток и текущее значение конкретного атрибута потока.

explicit timezone_io_saver(state_type &s);

Эффекты:Конструирует<timezone_io_saver>путем хранения<s>.

Этот конструктор работает так же, как предыдущий, и использует свой второй аргумент, чтобы изменить атрибут потока на новое значение типа аспекта.

explicit timezone_io_saver(state_type &s, aspect_type new_value);

Эффекты:Конструирует<timezone_io_saver>путем хранения<s>. Устанавливает<state_type><aspect_type>со значением<new_value>.

Деструктор восстанавливает атрибут потока к сохраненному значению.

~timezone_io_saver();

Эффекты:Как будто<restore>().

Восстановление может быть активировано рано (и часто) с помощью функции восстановления.

void restore();

Эффекты:Восстанавливает атрибут потока<timezone>к сохраненному значению.

template<typename CharT = char, typename Traits = std::char_traits<CharT> >
struct time_fmt_io_saver
{
  typedef std::basic_ios<CharT, Traits> state_type;
  explicit time_fmt_io_saver(state_type &s);
  time_fmt_io_saver(state_type &s, basic_string<CharT> const& new_value);
  ~time_fmt_io_saver();
  void restore();
};

<state_type>является версией шаблона базового класса IOStreams<std::basic_ios<CharT,Traits>>, где<CharT>является типом персонажа и<Traits>является классом признаков персонажа. Пользователь обычно размещает фактический объект ввода, вывода или комбинированного потока для параметра типа состояния, а не объект базового класса.

Этот конструктор берет объект потока и сохраняет ссылку на поток и текущее значение конкретного атрибута потока.

explicit time_fmt_io_saver(state_type &s);

Эффекты:Конструирует<time_fmt_io_saver>путем хранения<s>.

Этот конструктор работает так же, как предыдущий, и использует свой второй аргумент, чтобы изменить атрибут потока на новое значение типа аспекта.

explicit time_fmt_io_saver(state_type &s, aspect_type new_value);

Эффекты:Конструирует<time_fmt_io_saver>путем хранения<s>. Устанавливает<state_type><aspect_type>со значением<new_value>.

Деструктор восстанавливает атрибут потока к сохраненному значению.

~time_fmt_io_saver();

Эффекты:Как будто<restore>().

Восстановление может быть активировано рано (и часто) с помощью функции восстановления.

void restore();

Эффекты:Восстанавливает атрибут формата времени потока к сохраненному значению.

Template Class duration_get
namespace boost {
  namespace chrono {
    template <class CharT, class InputIterator = std::istreambuf_iterator<CharT> >
    class duration_get;
  }
}

template <class CharT, class InputIterator = std::istreambuf_iterator<CharT> >
class duration_get: public std::locale::facet
{
public:
  typedef CharT char_type; // Type of character the facet is instantiated on
  typedef std::basic_string<CharT> string_type; // Type of character string passed to member functions.
  typedef InputIterator iter_type; // Type of iterator used to scan the character buffer.
  explicit duration_get(size_t refs = 0);
  template <typename Rep, typename Period>
  iter_type get(
    iter_type s,
    iter_type end,
    std::ios_base& ios,
    std::ios_base::iostate& err,
    duration<Rep, Period>& d,
    const char_type* pattern,
    const char_type* pat_end
  ) const;
  template <typename Rep, typename Period>
  iter_type get(
    iter_type s,
    iter_type end,
    std::ios_base& ios,
    std::ios_base::iostate& err,
    duration<Rep, Period>& d
  ) const;
  template <typename Rep>
  iter_type get_value(
    iter_type s,
    iter_type end,
    std::ios_base& ios,
    std::ios_base::iostate& err,
    Rep& r
  ) const;
  iter_type get_unit(
    iter_type i,
    iter_type e,
    std::ios_base& is,
    std::ios_base::iostate& err,
    detail::rt_ratio &rt
  ) const
  static std::locale::id id; // Unique identifier for this type of facet.
  ~duration_get()
  {
  }
};

<duration_get>грань извлекает длительность из строки символа и сохраняет полученное значение в аргументе длительности класса d. Лицевая сторона парсирует строку, используя определенный формат в качестве руководства. Если строка не соответствует формату, то грань будет указывать на ошибку, установив аргумент ошибки в iosbase::failbit. Другими словами, подтверждение пользователя требуется для надежного анализа вводимых пользователем длительностей, но сгенерированные машиной форматы могут быть надежно проанализированы. Это позволяет парсерам быть агрессивными в интерпретации вариаций пользователей в стандартных форматах.

explicit duration_get(size_t refs);

Построена грань<duration_get>.

Параметры:

  • refs:ссылки

Эффекты:Конструирует<duration_get>грань. Если аргумент<refs>является<0>, то разрушение объекта делегируется в область, или области, содержащие его. Это позволяет пользователю игнорировать проблемы управления временем жизни. С другой стороны, если<refs><1>, то объект должен быть явно удален;<locale>не будет этого делать. В этом случае объект может поддерживаться в течение жизни нескольких мест.

~duration_get();

Уничтожает<duration_get>грань.

template <typename Rep, typename Period>
iter_type get(iter_type s, iter_type end, std::ios_base& ios, std::ios_base::iostate& err,
    duration<Rep, Period> &d, const char_type *pattern, const char_type *pat_end) const;

Извлекает продолжительность из диапазона<[s,end)>по образцу<[pattern,pat_end)>.

Параметры:

  • s:стартовый входной итератор потока
  • конец:конец входного потокового итератора
  • ios:ссылка на ios_base
  • ошибка:состояние ios_base
  • d:продолжительность
  • шаблон:начало шаблона форматирования
  • pat_end:конец шаблона форматирования

Требуется:<[s,end)and[pattern, pat_end)>должны быть действительными диапазонами.

Эффекты:Функция начинается с оценки<err= std::ios_base::goodbit>.

Затем он вычисляет промежуточное представление на основе<Rep>по следующим правилам:

  • Если<Rep>является типом с плавающей точкой, промежуточное представление<long double>.
  • Если<Rep>— подписанный интегральный тип, промежуточное представление —<longlong>.
  • Если<Rep>является неподписанным интегральным типом, промежуточное представление неподписано долго.
  • Другое промежуточное представление<Rep>.

Следующие локальные переменные<r>промежуточного представления типа и<rt>типа<rt_ratio>построены по умолчанию.

Затем он входит в цикл, считывая ноль или более символов<s>на каждой итерации. Если не указано иное ниже, цикл прекращается, когда выполняется первое из следующих условий:

  • Выражение<pattern ==pat_end>оценивает до<true>.
  • Выражение<err==std::ios_base::goodbit>оценивается как ложное.
  • Выражение<s==end>оценивает до<true>, в этом случае функция оценивает<err =std::ios_base::eofbit |std::ios_base::failbit>.
  • Следующий элемент паттерна равен<'%'>, за которым следует символ конверсионного спецификатора, формат. Если количество элементов в диапазоне<[pattern,pat_end)>недостаточно для однозначного определения того, является ли спецификация преобразования полной и действительной, функция оценивает<err= std::ios_base::failbit>. В противном случае функция оценивает<s= get_value(s, end, ios, err, r)>, когда спецификация преобразования является 'v', и<s =get_value(s,end,ios,err,rt)>, когда спецификация преобразования является 'u'. Если<err==std::ios_base::goodbit>сохраняется после оценки выражения, то функция инкрементирует паттерн, чтобы указать только на конец спецификации конверсии и продолжить циклизацию.
  • Выражение<isspace(*pattern,ios.getloc())>оценивает до<true>, и в этом случае функция сначала увеличивает паттерн до<pattern== pat_end|| !isspace(*pattern,ios.getloc())>оценивает до<true>, затем продвигается<s>до<s== end|| !isspace(*s,ios.getloc())>является<true>и, наконец, возобновляет циклирование.
  • Следующий символ, прочитанный из<s>, соответствует элементу, на который указывает паттерн в нечувствительном к случаю сравнении, и в этом случае функция оценивает<++pattern,++s>и продолжает зацикливание. В противном случае функция оценивает<err =std::ios_base::failbit>.

Если значение представления длительности и единица уточнения успешно разобраны, вычисление<(rt.num/rt.den)/(Period::num/Period::den)>сведено к самым низким значениям. Если это соотношение не может храниться без перелива, оценивает<err= std::ios_base::failbit>. В противном случае сохраните результат этого деления в<num>и<den>.

Если разделение не привело к переполнению, то вычислите<r*num/den>таким образом, чтобы избежать промежуточного переполнения. Если<r>имеет интегральный тип и это вычисление не будет точным, оценивает<err=std::ios_base::failbit>. Если результат вычисления переполнится<Rep>, оценивает<err= std::ios_base::failbit>. В противном случае результат<r* num/ den>используется для построения<duration<Rep,Period>>, который присваивается<d>.

Возвращение:<s>, итератор, указывающий чуть дальше последнего символа, который может быть определен как часть действительной продолжительности.

template <typename Rep, typename Period>
iter_type get(
  iter_type s,
  iter_type end,
  std::ios_base& ios,
  std::ios_base::iostate& err,
  duration<Rep, Period>& d
) const;

Извлекает продолжительность из диапазона<[s,end)>по шаблону по умолчанию.

Параметры:

  • s:стартовый входной итератор потока
  • конец:конец входного потокового итератора
  • ios:ссылка на ios_base
  • ошибка:состояние ios_base
  • d:продолжительность

Эффекты:Сохраняет шаблон длительности от __duration_unit, связанный с 'ios<in letsay >str'. Последний как будто

return get(s, end, ios, err, ios, d, str.data(), str.data() + str.size());

Возвращение:<s>, итератор, указывающий чуть дальше последнего символа, который может быть определен как часть действительной продолжительности.

template <typename Rep>
iter_type get_value(iter_type s, iter_type end, std::ios_base& ios, std::ios_base::iostate& err, Rep& r) const;

Извлекает представление длительности из диапазона<[s,end)>.

Параметры:

  • s:стартовый входной итератор потока
  • конец:конец входного потокового итератора
  • ios:ссылка на ios_base
  • ошибка:состояние ios_base
  • r:ссылка на представление продолжительности

Эффекты:Как будто

return std::use_facet<std::num_get<char_type, iter_type>>(ios.getloc()).get(s, end, ios, err, r);

Возврат:<s>, итератор, указывающий чуть дальше последнего символа, который может быть определен как часть действительного значения<Rep>.

iter_type get_unit(iter_type i, iter_type e, std::ios_base& is, std::ios_base::iostate& err, detail::rt_ratio &rt) const;

Извлекает единицу длительности из диапазона<[s,end)>.

Параметры:

  • s:стартовый входной итератор потока
  • конец:конец входного потокового итератора
  • ios:ссылка на ios_base
  • ошибка:состояние ios_base
  • rt:ссылка на отношение продолжительности выполнения-времени.

Эффекты:

  • Если первый символ<'['>, то делается попытка поглотить узор формы<"[N/D]">, где<N>и<D>имеют тип<unsignedlonglong>.
    • В случае успеха rt записывает значения<N>и<D>, в противном случае оценивает<err=std::ios_base::failbit>и возвращает<i>.
    • Возвращайте парсе самую длинную строку, соответствующую одной из единиц длительности, которая может следовать шаблону<"[N/D]">.
return do_get_n_d_prefix_unit(facet, i, e, is, err);
  • Иначе следующий персонаж не будет<'['>. Возвращайте парс самой длинной строкой, соответствующей одной из единиц длительности.
return do_get_prefix_unit(facet, i, e, is, err, rt);

Возвращение:<i>, итератор, указывающий чуть дальше последнего символа, который может быть определен как часть действительной единицы длительности.

virtual iter_type do_get_n_d_prefix_unit(
  duration_units<CharT> const &facet,
  iter_type i,
  iter_type e,
  std::ios_base&,
  std::ios_base::iostate& err
) const;

Извлекает отношение времени выполнения, связанное с продолжительностью, когда оно приведено в [N/D] форме.

Это точка расширения этого аспекта, так что мы можем принять во внимание другие периоды, которые могут иметь полезный перевод в других контекстах, например, дни и недели.

Параметры:

  • s:стартовый входной итератор потока
  • конец:конец входного потокового итератора
  • ios:ссылка на ios_base
  • ошибка:состояние ios_base
  • rt:ссылка на отношение продолжительности выполнения-времени.

Эффекты:Сканирование<s>для самой длинной из всех форм множественного числа, связанных с единицами продолжительности. В случае успеха установите соответствующее соотношение в<rt>. В противном случае<err=std::ios_base::failbit>.

Возвращение:<s>, итератор, указывающий чуть дальше последнего символа, который может быть определен как часть действительного имени.

virtual iter_type do_get_prefix_unit(
  duration_units<CharT> const &facet,
  iter_type i,
  iter_type e,
  std::ios_base&,
  std::ios_base::iostate& err,
  detail::rt_ratio &rt
) const;

Извлекает отношение времени выполнения, связанное с продолжительностью, когда оно приведено в префиксной форме.

Это точка расширения этого аспекта, так что мы можем принять во внимание другие периоды, которые могут иметь полезный перевод в других контекстах, например, дни и недели.

Параметры:

  • s:стартовый входной итератор потока
  • конец:конец входного потокового итератора
  • ios:ссылка на ios_base
  • ошибка:состояние ios_base
  • rt:ссылка на отношение продолжительности выполнения-времени.

Эффекты:Сканирование<s>для самой длинной из всех форм множественного числа, связанных с единицами продолжительности. В случае успеха установите соответствующее соотношение в<rt>. В противном случае<err=std::ios_base::failbit>.

Возвращение:<s>, итератор, указывающий чуть дальше последнего символа, который может быть определен как часть действительного имени.

Template Class duration_put
namespace boost {
  namespace chrono {
    template <class CharT, class OutputIterator = std::ostreambuf_iterator<CharT> >
    class duration_put;
  }
}

template <class CharT, class OutputIterator = std::ostreambuf_iterator<CharT> >
class duration_put: public std::locale::facet
{
public:
  typedef CharT char_type; // Type of character the facet is instantiated on.
  typedef std::basic_string<CharT> string_type; // Type of character string passed to member functions.
  typedef OutputIterator iter_type; // Type of iterator used to write in the character buffer.
  explicit duration_put(size_t refs = 0);
  template <typename Rep, typename Period>
  iter_type put(iter_type s, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d, const CharT* pattern,
      const CharT* pat_end) const;
  template <typename Rep, typename Period>
  iter_type put(iter_type s, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d) const;
  template <typename Rep, typename Period>
  iter_type put_value(iter_type s, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d) const;
  template <typename Rep, typename Period>
  iter_type put_unit(iter_type s, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d) const;
  static std::locale::id id; // Unique identifier for this type of facet.
  ~duration_put();
};

explicit duration_put(size_t refs);

Построена грань<duration_put>.

Параметры:

  • refs:ссылки

Эффекты:Конструирует грань<duration_put>. Если аргумент<refs>является аргументом<0>, то разрушение объекта делегируется локализации, или локализациям, содержащим его. Это позволяет пользователю игнорировать проблемы управления временем жизни. С другой стороны, если<refs>является<1>, то объект должен быть явно удален;<locale>не будет делать этого. В этом случае объект может поддерживаться в течение жизни нескольких мест.

~duration_put();

Уничтожает<duration_put>грань.

template <typename Rep, typename Period>
iter_type put(iter_type s, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d, const CharT* pattern,
    const CharT* pat_end) const;

Параметры:

  • s:выходной потоковый итератор
  • ios:ссылка на ios_base
  • d:продолжительность
  • шаблон:начало шаблона форматирования
  • pat_end:конец шаблона форматирования

Эффекты:Шаги через последовательность от<pattern>до<pat_end>, идентифицируя символы, которые являются частью последовательности шаблона. Каждый символ, который не является частью последовательности шаблонов, записывается на<s>немедленно, и каждая последовательность шаблонов, как она идентифицирована, приводит к вызову<put_value>или<put_unit>; таким образом, элементы шаблонов и другие символы переплетаются на выходе в порядке, в котором они появляются в шаблоне. Последовательности шаблонов идентифицируются путем преобразования каждого символа<c>в<char>значение, как если бы<ct.narrow(c,0)>, где<ct>является ссылкой на<ctype<charT>>, полученной из<ios.getloc()>. Первый символ каждой последовательности равен<'%'>, за которым следует спецификатор символов паттерна, который может быть<'v'>для значения продолжительности или<'u'>для единицы продолжительности. Для каждой достоверной идентифицированной последовательности шаблонов вызовы<put_value(s,ios,d)>или<put_unit(s,ios,d)>.

Возвращение:Итератор, указывающий сразу после создания последнего персонажа.

template <typename Rep, typename Period>
iter_type put(iter_type s, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d) const;

Параметры:

  • s:выходной потоковый итератор
  • ios:ссылка на ios_base
  • d:продолжительность

Retrieves Сохраняет шаблон продолжительности из __duration_unit, скажем<str>. Последний как будто

return put(s, ios, d, str.data(), str.data() + str.size());

Возвращение:Итератор, указывающий сразу после создания последнего персонажа.

template <typename Rep, typename Period>
iter_type put_value(iter_type s, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d) const;

Параметры:

  • s:выходной потоковый итератор
  • ios:ссылка на ios_base
  • d:продолжительность

Эффекты:Как будто std::use_facet>(ios.getloc()).put(s, ios, '', static_cast(d.count())).

Возвращение:Итератор, указывающий сразу после создания последнего персонажа.

template <typename Rep, typename Period>
iter_type put_unit(iter_type s, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d) const;

Параметры:

  • s:выходной потоковый итератор
  • ios:ссылка на ios_base
  • заполнение:заполнение символ
  • d:продолжительность

Эффекты:Пусть<facet>будет<duration_units<CharT>>гранью, связанной с<ios>. Если название ассоциированной единицы, как если бы

string_type str = facet.get_unit(get_duration_style(ios), d);
s=std::copy(str.begin(), str.end(), s);

В противном случае, отформатируйте блок как<"[Period::num/Period::den]">, за которым следует блок, связанный с [N/D], полученный с использованием<facet.get_n_d_unit(get_duration_style(ios),d)>.

Возвращение:с, итератор, указывающий сразу после последнего произведенного персонажа.

Class rt_ratio
Template Class duration_units
Template Class duration_units_default
namespace boost {
  namespace chrono {
    class rt_ratio;
    template <typename CharT = char>
    class duration_units;
  }
}

class rt_ratio
{
public:
  template <typename Period>
  rt_ratio(Period const&) :
    num(Period::type::num), den(Period::type::den)
  {
  }
  rt_ratio(intmax_t n = 0, intmax_t d = 1) :
    num(n), den(d)
  {
  }
  intmax_t num;
  intmax_t den;
};

template <typename CharT = char>
class duration_units: public std::locale::facet
{
public:
  typedef CharT char_type; // Type of character the facet is instantiated on.
  typedef std::basic_string<CharT> string_type; // Type of character string passed to member functions.
  static std::locale::id id; // Unique identifier for this type of facet.
  explicit duration_units(size_t refs = 0);
  virtual const string_type* get_n_d_valid_units_start() const =0;
  virtual const string_type* get_n_d_valid_units_end() const=0;
  virtual const string_type* get_valid_units_start() const=0;
  virtual const string_type* get_valid_units_end() const=0;
  virtual bool match_n_d_valid_unit(const string_type* k) const = 0;
  virtual bool match_valid_unit(const string_type* k, rt_ratio& rt) const = 0;
  virtual string_type get_pattern() const=0;
  template <typename Rep, typename Period>
  string_type get_unit(duration_style style, duration<Rep, Period> const& d) const;
  template <typename Rep, typename Period>
  string_type get_n_d_unit(duration_style style, duration<Rep, Period> const& d) const;
  template <typename Period>
  bool is_named_unit() const;
protected:
  virtual ~duration_units();
  virtual string_type do_get_n_d_unit(duration_style style, rt_ratio rt, intmax_t v) const = 0;
  virtual string_type do_get_unit(duration_style style,rt_ratio rt, intmax_t v) const = 0;
  virtual bool do_is_named_unit(rt_ratio rt) const =0;
};

<duration_units>грань дает полезную информацию о единицах продолжительности, таких как число форм множественного числа, форма множественного числа, связанная с продолжительностью, текст, связанный с формой множественного числа и периодом продолжительности,

explicit duration_units(size_t refs = 0);

Постройте<duration_units>грань.

Параметры:

  • refs:ссылки

Эффекты:Постройте<duration_units>грань. Если<refs>аргумент<0>, то разрушение объекта делегируется на место, или места, содержащие его. Это позволяет пользователю игнорировать проблемы управления временем жизни. С другой стороны, если<refs>является<1>, то объект должен быть явно удален; область не будет делать этого. В этом случае объект может поддерживаться в течение жизни нескольких мест.

virtual ~duration_units();

Эффекты:Уничтожает грани.

virtual const string_type* get_n_d_valid_units_start() const =0;

Возврат:указатель на начало действительных [N/D] единиц.

virtual const string_type* get_n_d_valid_units_end() const=0;

Возврат:указатель на конец действительных единиц [N/D].

virtual const string_type* get_valid_units_start() const=0;

Возврат:указывает на начало действительных единиц, символа или префикса с его различными множественными формами.

virtual const string_type* get_valid_units_end() const=0;

указывает на конец действительных единиц.

virtual bool match_n_d_valid_unit(const string_type* k) const = 0;

Параметры:

  • k:найденный указатель на [N/D] блок.

Возврат:<true>, если<k>соответствует действительной единице.

virtual bool match_valid_unit(const string_type* k, rt_ratio& rt) const = 0;

Параметры:

  • k:найденный указатель на единицу.

Эффекты:<rt>устанавливается на действительный период, когда<k>соответствует действительной единице.Возврат:<true>, если<k>соответствует действительной единице.

virtual string_type get_pattern() const=0;

Возврат:шаблон, который будет использоваться по умолчанию.

template <typename Rep, typename Period>
string_type get_unit(duration_style style, duration<Rep, Period> const& d) const;

Возврат:<get_unit(style,d.count(),rt_ratio(Period()))>, единица, связанная с этой продолжительностью.

template <typename Rep, typename Period>
string_type get_n_d_unit(duration_style style, duration<Rep, Period> const& d) const;

Возврат:get_n_d_unit(style, d.count(), rt_ratio(Period())), т.е. единица суффикса [N/D], связанная с этой продолжительностью.

template <typename Period>
bool is_named_unit() const;

Возврат:<do_is_named_unit(rt_ratio(Period()))>, истинно, если единица, связанная с данным Периодом, названа, ложно иначе.

virtual string_type do_get_n_d_unit(duration_style style, rt_ratio rt, intmax_t v) const = 0;

Возврат:единица суффикса [N/D], связанная с этой продолжительностью.

virtual string_type do_get_unit(duration_style style,rt_ratio rt, intmax_t v) const = 0;

Возвращает:единицу, связанную с этой продолжительностью.

virtual bool do_is_named_unit(rt_ratio rt) const =0;

Возврат:истинно, если единица, связанная с данным Периодом, названа, ложно иначе.

template <typename CharT = char>
class duration_units_default: public duration_units<CharT>
{
protected:
  static const std::size_t pfs_ = 2; // The default English facet has two plural forms.
public:
  typedef CharT char_type;
  typedef std::basic_string<CharT> string_type;
  explicit duration_units_default(size_t refs = 0);
  ~duration_units_default();
  bool match_n_d_valid_unit(const string_type* k) const;
  bool match_valid_unit(const string_type* k, rt_ratio& rt) const;
  const string_type* get_n_d_valid_units_start()const;
  const string_type* get_n_d_valid_units_end()const;
  string_type* get_valid_units_start() const;
  string_type* get_valid_units_end() const;
  string_type get_pattern() const;
protected:
  bool do_is_named_unit(rt_ratio rt) const;
  string_type do_get_n_d_unit(duration_style style, rt_ratio, intmax_t v) const;
  string_type do_get_unit(duration_style style, rt_ratio rt, intmax_t v) const;
  virtual std::size_t do_get_plural_forms() const;
  virtual std::size_t do_get_plural_form(int_least64_t value) const;
  virtual string_type do_get_unit(duration_style style, ratio<1> u, std::size_t pf) const;
  virtual string_type do_get_unit(duration_style style, ratio<60> u, std::size_t pf) const;
  virtual string_type do_get_unit(duration_style style, ratio<3600> u, std::size_t pf) const;
  virtual string_type do_get_unit(duration_style style, atto u, std::size_t pf) const;
  virtual string_type do_get_unit(duration_style style, femto u, std::size_t pf) const;
  virtual string_type do_get_unit(duration_style style, pico u, std::size_t pf) const;
  virtual string_type do_get_unit(duration_style style, nano u, std::size_t pf) const;
  virtual string_type do_get_unit(duration_style style, micro u, std::size_t pf) const;
  virtual string_type do_get_unit(duration_style style, milli u, std::size_t pf) const;
  virtual string_type do_get_unit(duration_style style, centi u, std::size_t pf) const;
  virtual string_type do_get_unit(duration_style style, deci u, std::size_t pf) const;
  virtual string_type do_get_unit(duration_style style, deca u, std::size_t pf) const;
  virtual string_type do_get_unit(duration_style style, hecto u, std::size_t pf) const;
  virtual string_type do_get_unit(duration_style style, kilo u, std::size_t pf) const;
  virtual string_type do_get_unit(duration_style style, mega u, std::size_t pf) const;
  virtual string_type do_get_unit(duration_style style, giga u, std::size_t pf) const;
  virtual string_type do_get_unit(duration_style style, tera u, std::size_t pf) const;
  virtual string_type do_get_unit(duration_style style, peta u, std::size_t pf) const;
  virtual string_type do_get_unit(duration_style style, exa u, std::size_t pf) const;
  virtual string_type do_get_ratio_prefix(duration_style style, atto u) const;
  virtual string_type do_get_ratio_prefix(duration_style style, femto u) const;
  virtual string_type do_get_ratio_prefix(duration_style style, pico u) const;
  virtual string_type do_get_ratio_prefix(duration_style style, nano u) const;
  virtual string_type do_get_ratio_prefix(duration_style style, micro u) const;
  virtual string_type do_get_ratio_prefix(duration_style style, milli u) const;
  virtual string_type do_get_ratio_prefix(duration_style style, centi u) const;
  virtual string_type do_get_ratio_prefix(duration_style style, deci u) const;
  virtual string_type do_get_ratio_prefix(duration_style style, deca u) const;
  virtual string_type do_get_ratio_prefix(duration_style style, hecto u) const;
  virtual string_type do_get_ratio_prefix(duration_style style, kilo u) const;
  virtual string_type do_get_ratio_prefix(duration_style style, mega u) const;
  virtual string_type do_get_ratio_prefix(duration_style style, giga u) const;
  virtual string_type do_get_ratio_prefix(duration_style style, tera u) const;
  virtual string_type do_get_ratio_prefix(duration_style style, peta u) const;
  virtual string_type do_get_ratio_prefix(duration_style style, exa u) const;
};

Этот класс используется для определения строк для английского языка по умолчанию. Эта грань обозначает единицы, связанные со следующими периодами:

  • <atto>,
  • <femto>,
  • <pico>,
  • <nano>,
  • <micro>,
  • <milli>,
  • <centi>,
  • <deci>,
  • ratio<1>,
  • <deca>,
  • <hecto>,
  • <kilo>,
  • <mega>,
  • <giga>,
  • <tera>,
  • <peta>,
  • <exa>,
  • ratio<60>и
  • Соотношение<3600>.
explicit duration_units_default(size_t refs = 0);

Постройте аспект long_units_default.

Параметры:

  • refs:ссылки

Эффекты:Постройте грань длительности_units_default. Если аргумент<refs>является<0>, то разрушение объекта делегируется на локализацию, или локализации, содержащие его. Это позволяет пользователю игнорировать проблемы управления временем жизни. С другой стороны, если<refs>является<1>, то объект должен быть явно удален. В этом случае объект может поддерживаться в течение жизни нескольких мест.

virtual ~duration_units_default();

Эффекты:Уничтожает грани.

virtual const string_type* get_n_d_valid_units_start() const;

Возврат:указатель на начало действительных [N/D] единиц.

virtual const string_type* get_n_d_valid_units_end() const;

Возврат:указатель на конец действительных единиц [N/D].

virtual const string_type* get_valid_units_start() const;

Возврат:указывает на начало действительных единиц, символа или префикса с его различными множественными формами.

virtual const string_type* get_valid_units_end() const;

указывает на конец действительных единиц.

virtual bool match_n_d_valid_unit(const string_type* k) const;

Параметры:

  • k:найденный указатель на [N/D] блок.

Возврат:<true>, если<k>соответствует действительной единице.

virtual bool match_valid_unit(const string_type* k, rt_ratio& rt) const;

Параметры:

  • k:найденный указатель на единицу.

Эффекты:<rt>устанавливается на действительный период, когда<k>соответствует действительной единице.Возврат:<true>, если<k>соответствует действительной единице.

virtual string_type get_pattern() const;

Возврат:шаблон, который будет использоваться по умолчанию.

virtual string_type do_get_n_d_unit(duration_style style, rt_ratio rt, intmax_t v) const;

Возврат:единица суффикса [N/D], связанная с этой продолжительностью.

virtual string_type do_get_unit(duration_style style,rt_ratio rt, intmax_t v) const;

Возвращает:единицу, связанную с этой продолжительностью.

virtual bool do_is_named_unit(rt_ratio rt) const;

Возврат:истинно, если единица, связанная с данным Периодом, названа, ложно иначе.

virtual std::size_t do_get_plural_forms() const;

Возвращает:число связанных множественных форм, которыми управляет эта грань.

virtual std::size_t do_get_plural_form(int_least64_t value) const;

Получает ассоциированную множественную форму.

Параметры:

значение:представление продолжительности

Возвращает:множественную форму, связанную с<value>параметром. В английском языке существует 2 формы множественного числа

  • 0 сингулярно (-1 или 1)
  • 1 множественное число для всех остальных
virtual string_type do_get_unit(duration_style style, ratio<1> u, std::size_t pf) const;

Параметры:

  • стиль:стиль продолжительности.
  • период:период, связанный с продолжительностью часов.
  • pf:запрашиваемая форма множественного числа.

Возврат:, если стиль является символом, возвращает «s», в противном случае, если pf равен 0, возвращает «второй», если pf равен 1 «секунде».

virtual string_type do_get_unit(duration_style style, ratio<60> u, std::size_t pf) const;

Параметры:

  • стиль:стиль продолжительности.
  • период:период, связанный с продолжительностью часов.
  • pf:запрашиваемая форма множественного числа.

Возврат:, если стиль является символом, возвращает «мин», в противном случае, если pf равен 0, возвращает «минута», если pf равен 1 «минуте».

virtual string_type do_get_unit(duration_style style, ratio<3600> u, std::size_t pf) const;

Параметры:

  • стиль:стиль продолжительности.
  • период:период, связанный с продолжительностью часов.
  • pf:запрашиваемая форма множественного числа.

Возврат:, если стиль является символом, возвращает «h», в противном случае, если pf равен 0, возвращает «час», если pf равен 1 «часу».

virtual string_type do_get_unit(duration_style style, atto u, std::size_t pf) const;
virtual string_type do_get_unit(duration_style style, femto u, std::size_t pf) const;
virtual string_type do_get_unit(duration_style style, pico u, std::size_t pf) const;
virtual string_type do_get_unit(duration_style style, nano u, std::size_t pf) const;
virtual string_type do_get_unit(duration_style style, micro u, std::size_t pf) const;
virtual string_type do_get_unit(duration_style style, milli u, std::size_t pf) const;
virtual string_type do_get_unit(duration_style style, centi u, std::size_t pf) const;
virtual string_type do_get_unit(duration_style style, deci u, std::size_t pf) const;
virtual string_type do_get_unit(duration_style style, deca u, std::size_t pf) const;
virtual string_type do_get_unit(duration_style style, hecto u, std::size_t pf) const;
virtual string_type do_get_unit(duration_style style, kilo u, std::size_t pf) const;
virtual string_type do_get_unit(duration_style style, mega u, std::size_t pf) const;
virtual string_type do_get_unit(duration_style style, giga u, std::size_t pf) const;
virtual string_type do_get_unit(duration_style style, tera u, std::size_t pf) const;
virtual string_type do_get_unit(duration_style style, peta u, std::size_t pf) const;
virtual string_type do_get_unit(duration_style style, exa u, std::size_t pf) const;

Параметры:

  • стиль:стиль продолжительности.
  • у:период тег на.
  • pf:запрашиваемая форма множественного числа.

Возвращает:сцепление префикса, связанное с периодом<u>+ тот, который связан с секундами.

virtual string_type do_get_ratio_prefix(duration_style style, atto u) const;
virtual string_type do_get_ratio_prefix(duration_style style, femto u) const;
virtual string_type do_get_ratio_prefix(duration_style style, pico u) const;
virtual string_type do_get_ratio_prefix(duration_style style, nano u) const;
virtual string_type do_get_ratio_prefix(duration_style style, micro u) const;
virtual string_type do_get_ratio_prefix(duration_style style, milli u) const;
virtual string_type do_get_ratio_prefix(duration_style style, centi u) const;
virtual string_type do_get_ratio_prefix(duration_style style, deci u) const;
virtual string_type do_get_ratio_prefix(duration_style style, deca u) const;
virtual string_type do_get_ratio_prefix(duration_style style, hecto u) const;
virtual string_type do_get_ratio_prefix(duration_style style, kilo u) const;
virtual string_type do_get_ratio_prefix(duration_style style, mega u) const;
virtual string_type do_get_ratio_prefix(duration_style style, giga u) const;
virtual string_type do_get_ratio_prefix(duration_style style, tera u) const;
virtual string_type do_get_ratio_prefix(duration_style style, peta u) const;
virtual string_type do_get_ratio_prefix(duration_style style, exa u) const;

Параметры:

  • стиль:стиль продолжительности.
  • у:период тег на.

Возврат:в зависимости от значения<style>возвращают символ или префикс ratio_string.

I/O Manipulators
I/O Streams Operations
namespace boost {
  namespace chrono {
    // manipulators
    std::ios_base& symbol_format(ios_base& ios);
    std::ios_base& name_format(ios_base& ios);
    class duration_fmt;
    template<class CharT, class Traits>
    std::basic_ostream<CharT, Traits>&
    operator <<(std::basic_ostream<CharT, Traits>& os, duration_fmt d);
    template<class CharT, class Traits>
    std::basic_istream<CharT, Traits>&
    operator >>(std::basic_istream<CharT, Traits>& is, duration_fmt d);
    // duration I/O
    template <class CharT, class Traits, class Rep, class Period>
        std::basic_ostream<CharT, Traits>&
        operator <<(std::basic_ostream<CharT, Traits>& os, const duration<Rep, Period>& d);
    template <class CharT, class Traits, class Rep, class Period>
        std::basic_istream<CharT, Traits>&
        operator >>(std::basic_istream<CharT, Traits>& is, duration<Rep, Period>& d)
  }
}

Существует параметризованный манипулятор, который принимает в качестве параметра стиль длительности. Формат символа или имени может быть легко выбран путем потоковой передачи манипуляторов<symbol_format>или<name_format>соответственно.

class duration_fmt
{
public:
  explicit duration_fmt(duration_style style) noexcept;
#ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
  explicit
  operator duration_style() const noexcept;
#endif
  duration_style get_duration_style() const noexcept;
};
template<class CharT, class Traits>
std::basic_ostream<CharT, Traits>&
operator <<(std::basic_ostream<CharT, Traits>& os, duration_fmt d);
template<class CharT, class Traits>
std::basic_istream<CharT, Traits>&
operator >>(std::basic_istream<CharT, Traits>& is, duration_fmt d);

explicit duration_fmt(duration_style f) noexcept;

Эффекты:Конструирует<duration_fmt>путем хранения<f>.

Условия поста:<static_cast<duration_style>(*this)==f>.

explicit operator duration_style() const noexcept;
duration_style get_duration_style() const noexcept;

Возвращение::<duration_fmt><f>.

template<class CharT, class Traits>
  basic_ostream<CharT, Traits>&
  operator<<(basic_ostream<CharT, Traits>& s, duration_fmt d);

Эффекты::<set_duration_style>s,static_cast<<duration_style>>d)]].

Возвращение::<s>.

template<class CharT, class Traits>
  basic_istream<CharT, Traits>&
  operator>>(basic_istream<CharT, Traits>& s, duration_fmt d);

Эффекты::<set_duration_style>s,static_cast<<duration_style>>d)]].

Возвращение::<s>.

std::ios_base& symbol_format(ios_base& ios);

Эффекты::<set_duration_style>s,<duration_style>::символ.

Возвращение:<ios>

std::ios_base& name_format(ios_base& ios);

Эффекты::<set_duration_style>s,<duration_style>::префикс.

Возвращение:<ios>

Любой<duration>может быть передан<basic_ostream>. Значение времени выполнения<duration>отформатировано в соответствии с правилами и текущими настройками формата для<duration><::rep>и<duration_units>.

template <class CharT, class Traits, class Rep, class Period>
    std::basic_ostream<CharT, Traits>&
    operator<<(std::basic_ostream<CharT, Traits>& os, const duration<Rep, Period>& d);

Эффекты:Ведет себя как отформатированная выходная функция. После построения сторожевого объекта, если сторожевой преобразуется в истинный, вызывает<facet.put>os,ososd, где<facet>является<duration_put><2687]CharTгранью, связанной с<os>или новым созданным экземпляром по умолчанию<duration_put><CharT>>

Возвращение:<os>.

template <class CharT, class Traits, class Rep, class Period>
    std::basic_istream<CharT, Traits>&
    operator>>(std::basic_istream<CharT, Traits>& is, duration<Rep, Period>& d)

Эффекты:Ведет себя как отформатированная входная функция. После конструирования<sentry>объекта, если<sentry>преобразуется в<true>, вызывает<facet.get>stdistreambuf_iterator<CharT>(),являетсяerrd, где<facet>является<duration_get>>, связанным с<is>или новым созданным экземпляром по умолчанию<duration_get><CharT>

Если что-то не получается, звоните<os.setstate(std::ios_base::failbit |std::ios_base::badbit)>.

Возвращение:<is>

Template Class time_point_get
namespace boost {
  namespace chrono {
    template <class CharT, class InputIterator = std::istreambuf_iterator<CharT> >
    class time_point_get;
  }
}

template <class CharT, class InputIterator = std::istreambuf_iterator<CharT> >
class time_point_get: public std::locale::facet
{
public:
  typedef CharT char_type; // Type of character the facet is instantiated on.
  typedef InputIterator iter_type; // Type of iterator used to scan the character buffer.
  explicit __time_point_get_c(size_t refs = 0);
  template <class Clock, class Duration>
  iter_type __time_point_get_get(iter_type i, iter_type e, std::ios_base& is, std::ios_base::iostate& err,
      time_point<Clock, Duration> &tp, const char_type *pattern, const char_type *pat_end) const;
  template <class Clock, class Duration>
  iter_type __time_point_get_get2(iter_type i, iter_type e, std::ios_base& is, std::ios_base::iostate& err,
      time_point<Clock, Duration> &tp) const;
  template <typename Rep, typename Period>
  iter_type __time_point_get_get_duration(iter_type i, iter_type e, std::ios_base& is, std::ios_base::iostate& err,
      duration<Rep, Period>& d) const;
  template <class Clock>
  iter_type __time_point_get_get_epoch(iter_type i, iter_type e, std::ios_base& is, std::ios_base::iostate& err) const;
  static std::locale::id id; // Unique identifier for this type of facet.
  __time_point_get_d();
};

<time_point_get>используется для разбора последовательности символов, извлекая продолжительность и эпоху в класс<time_point>.

Узор может содержать спецификаторы формата<%d>и<%e>в любом порядке.

Подтверждение пользователя требуется для надежного анализа вводимых пользователем длительностей, но сгенерированные машиной форматы могут быть надежно проанализированы. Это позволяет парсерам быть агрессивными в интерпретации вариаций пользователей в стандартных форматах.

Если конечный итератор достигнут при разборе наборов функций члена<std::ios_base::eofbit>в<err>.

explicit time_point_get(size_t refs);

Построение __time_point_get facet.

Параметры:

  • refs:ссылки

Эффекты:Конструирует грань<duration_put>. Если аргумент<refs>является аргументом<0>, то разрушение объекта делегируется локализации, или локализациям, содержащим его. Это позволяет пользователю игнорировать проблемы управления временем жизни. С другой стороны, если<refs>является<1>, то объект должен быть явно удален;<locale>не будет делать этого. В этом случае объект может поддерживаться в течение жизни нескольких мест.

~time_point_get();

Эффекты:Уничтожить грань.

template <class Clock, class Duration>
iter_type get(iter_type s, iter_type end, std::ios_base& ios, std::ios_base::iostate& err,
    time_point<Clock, Duration> &tp, const char_type *pattern, const char_type *pat_end) const;

Параметры:

  • s:стартовый входной итератор потока
  • конец:конец входного потокового итератора
  • ios:ссылка на<ios_base>
  • Ошибка:<ios_base::iostate>
  • tp:<time_point>
  • шаблон:начало шаблона форматирования
  • pat_end:конец шаблона форматирования

<[pattern,pat_end)>должен быть действительным диапазоном.

Эффекты:: Функция начинается с оценки<err= std::ios_base::goodbit>. Затем он входит в цикл, считывая ноль или более символов<s>на каждой итерации. Если не указано иное ниже, цикл прекращается, когда выполняется первое из следующих условий:

  • Выражение<pattern ==pat_end>оценивает до<true>.
  • Выражение<err==std::ios_base::goodbit>соответствует<false>.
  • Выражение<s==end>оценивает до<true>, в этом случае функция оценивает<err =std::ios_base::eofbit |std::ios_base::failbit>.
  • Следующий элемент рисунка равен<'%'>, за которым следует символ конверсионного спецификатора, функции<get_duration>или<get_epoch>называются в зависимости от того, является ли формат<'d'>или<'e'>. Если количество элементов в диапазоне<[pattern,pat_end)>недостаточно для однозначного определения того, является ли спецификация преобразования полной и действительной, функция оценивает<err|= std::ios_base::failbit>. В противном случае функция оценивает<s= do_get(s, end, ios, err, d)>. Если<err== std::ios_base::goodbit>выполняется после оценки выражения, шаблон приращения функции указывает только на конец спецификации преобразования и продолжает зацикливаться.
  • Выражение<isspace(*pattern,ios.getloc())>оценивает до<true>, и в этом случае функция сначала прирастает<pattern>до<pattern==pat_end ||!isspace(*pattern, ios.getloc())>оценивает до<true>, затем продвигается<s>до<s== end|| !isspace(*s,ios.getloc())>является<true>и, наконец, возобновляет циклирование.
  • Следующий символ, прочитанный из<s>, соответствует элементу, на который указывает паттерн в нечувствительном к случаю сравнении, и в этом случае функция оценивает<++pattern>,<++s>и продолжает зацикливание. В противном случае функция оценивает<err= std::ios_base::failbit>.

Возвращение:Итератор, указывающий чуть дальше последнего символа, который может быть определен как часть действительной точки времени.

template <class Clock, class Duration>
iter_type get(iter_type s, iter_type end, std::ios_base& ios, std::ios_base::iostate& err,
    time_point<Clock, Duration> &tp) const;

Параметры:

  • s:стартовый входной итератор потока
  • конец:конец входного потокового итератора
  • ios:ссылка на<ios_base>
  • Ошибка:<ios_base::iostate>
  • tp:<time_point>

Эффекты:Сохраняет закономерность длительности от<duration_unit>грань, скажем<str>. Последний как будто

return get(s, end, ios, err, ios, d, str.data(), str.data() + str.size());

Возвращение:Итератор, указывающий только на последний символ, который может быть определен как часть действительного имени.

template <typename Rep, typename Period>
iter_type get_duration(iter_type s, iter_type end, std::ios_base& ios, std::ios_base::iostate& err,
    duration<Rep, Period>& d) const;

Эффекты:Как будто

return facet.get(s, end, ios, err, d);

где<facet>— либо грань<duration_get>, связанная с<ios>, либо грань по умолчанию<duration_get>.

Возвращение:Итератор, указывающий только на последний символ, который может быть определен как часть действительной продолжительности.

template <class Clock>
iter_type get_epoch(iter_type s, iter_type end, std::ios_base& ios, std::ios_base::iostate& err) const;

Эффекты:Пусть<facet>будет<time_point_units>гранью, ассоциированной с<ios>, или новым экземпляром по умолчанию __time_point_units_default гранью. Пусть<epoch>будет строкой эпохи, связанной с<Clock>, используя эту грань. Сканирование<s>, чтобы соответствовать<epoch>или<end>.

Если не совпадать до достижения<end><std::ios_base::failbit>, то устанавливается<err>. Если<end>достигнут<std::ios_base::failbit>, то<err>установлен.

Возвращение:Итератор, указывающий чуть дальше последнего персонажа, который можно определить как часть эпохи.

Template Class time_point_put
namespace boost {
  namespace chrono {
    template <class CharT, class OutputIterator = std::ostreambuf_iterator<CharT> >
    class time_point_put;
  }
}

Форму __time_point_put обеспечивают возможности для форматированного вывода значений<time_point>. Функция __time_point_put берет<time_point>и форматирует его в представление строк символов.

парам ChatT — тип персонажа tparam OutputIterator модель<OutputIterator>

template <class CharT, class OutputIterator = std::ostreambuf_iterator<CharT> >
class time_point_put: public std::locale::facet
{
public:
  typedef CharT char_type; // Type of character the facet is instantiated on.
  typedef std::basic_string<CharT> string_type; // Type of character string passed to member functions.
  typedef OutputIterator iter_type; // Type of iterator used to write in the character buffer.
  explicit time_point_put(size_t refs = 0);
  ~time_point_put();
  template <class Clock, class Duration>
  iter_type put(iter_type i, std::ios_base& ios, char_type fill, time_point<Clock, Duration> const& tp, const CharT* pattern,
      const CharT* pat_end) const;
  template <class Clock, class Duration>
  iter_type put(iter_type i, std::ios_base& ios, char_type fill, time_point<Clock, Duration> const& tp) const;
  template <typename Rep, typename Period>
  iter_type put_duration(iter_type i, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d) const;
  template <typename Clock>
  iter_type put_epoch(iter_type i, std::ios_base& os) const;
  static std::locale::id id; // Unique identifier for this type of facet.
};

explicit time_point_put(size_t refs = 0);

Постройте грань time_point_put.

Эффекты:Постройте грань Time_point_put. Если аргумент<refs>является<0>, то разрушение объекта делегируется в область, или области, содержащие его. Это позволяет пользователю игнорировать проблемы управления временем жизни. С другой стороны, если<refs>является<1>, то объект должен быть явно удален. В этом случае объект может поддерживаться в течение жизни нескольких мест.

Параметры:

  • refs:ссылки
template <class Clock, class Duration>
iter_type put(iter_type i, std::ios_base& ios, char_type fill, time_point<Clock, Duration> const& tp, const CharT* pattern,
    const CharT* pat_end) const;

Параметры:

  • i:Итератор выходного потока
  • ios:ссылка на ios_base
  • заполнить:символ, используемый в качестве наполнителя
  • tp:<time_point>
  • шаблон:начало шаблона форматирования
  • pat_end:конец шаблона форматирования

Эффекты:Шаги по последовательности от<pattern>до<pat_end>, идентифицирующие символы, которые являются частью последовательности шаблонов. Каждый символ, который не является частью последовательности шаблонов, записывается<s>немедленно, и каждая последовательность шаблонов, как она определена, приводит к вызову __put_duration или __put_epoch; таким образом, элементы шаблона и другие символы переплетаются на выходе в порядке, в котором они появляются в шаблоне. Последовательности шаблонов идентифицируются путем преобразования каждого символа<c>в<char>значение, как если бы<ct.narrow(c,0)>, где<ct>является ссылкой на<ctype<charT>>, полученной из<ios.getloc()>. Первый символ каждой последовательности равен<'%'>, за которым следует спецификация символа паттерна, которая может быть<'d'>для значения длительности или<'e'>для эпохи. Для каждой достоверной идентифицированной последовательности шаблонов вызовы<put_duration(s,ios,fill,tp.time_since_epoch())>или<put_epoch(s,ios)>.

Возвращение:Итератор, указывающий сразу после создания последнего персонажа.

template <class Clock, class Duration>
iter_type put(iter_type i, std::ios_base& ios, char_type fill, time_point<Clock, Duration> const& tp) const;

Параметры:

  • i:Итератор выходного потока
  • ios:ссылка на ios_base
  • заполнить:символ, используемый в качестве наполнителя
  • tp:<time_point>
  • tern:начало шаблона форматирования
  • pat_end:конец шаблона форматирования

Эффекты:Хранит шаблон time_point из грани __time_point_unit, скажем<str>. Последний как будто

return put(s, ios, fill, tp, str.data(), str.data() + str.size());

Возвращение:Итератор, указывающий сразу после создания последнего персонажа.

template <typename Rep, typename Period>
iter_type put_duration(iter_type i, std::ios_base& ios, char_type fill, duration<Rep, Period> const& d) const;

Параметры:

  • i:Итератор выходного потока
  • ios:ссылка на ios_base
  • заполнить:символ, используемый в качестве наполнителя
  • d:<duration>

Эффекты:Как будто<facet.put(s,ios,fill,d)>, где гранью является<duration_put><CharT>грань, связанная с<ios>или новым экземпляром<duration_put><CharT>.

Возвращение:Итератор, указывающий сразу после создания последнего персонажа.

template <typename Clock>
iter_type put_epoch(iter_type i, std::ios_base& os) const;

Параметры:

  • i:Итератор выходного потока
  • ios:ссылка на ios_base

Эффекты:Как будто

string_type str = facet.template get_epoch<Clock>();
s=std::copy(str.begin(), str.end(), s);

где грань —<time_point_units><CharT>грань, связанная с<ios>или новым экземпляром<__time_point_units_default<CharT>>.

Возвращение:с, итератор, указывающий сразу после последнего произведенного персонажа.

Template Function get_epoch_custom
Template Class time_point_units
Template Class time_point_units_default
namespace boost {
  namespace chrono {
    template <typename CharT, typename Clock, typename TPUFacet>
    std::basic_string<CharT> get_epoch_custom(Clock, TPUFacet& f);
    template <typename CharT=char>
    class time_point_units;
    template <typename CharT=char>
    class time_point_units_default,
  }
}

template <typename CharT, typename Clock, typename TPUFacet>
std::basic_string<CharT> get_epoch_custom(Clock, TPUFacet& f);

Настройка указывает на эпоху, связанную с часами<Clock>. По умолчанию вызывает<f.do_get_epoch(Clock())>.

Пользователь может перегрузить эту функцию.

Возвращение:Призыв в сторону как бы

return f.do_get_epoch(Clock());

<time_point_units>грань дает полезную информацию о шаблоне time_point, тексте, связанном с эпохой time_point,

  template <typename CharT=char>
  class time_point_units: public std::locale::facet
  {
  public:
    typedef CharT char_type; // Type of character the facet is instantiated on.
    typedef std::basic_string<char_type> string_type; // Type of character string used by member functions.
    static std::locale::id id; // Unique identifier for this type of facet.
    explicit time_point_units(size_t refs = 0);
    virtual string_type get_pattern() const =0;
    template <typename Clock>
    string_type get_epoch() const;
  protected:
    virtual ~time_point_units();
    virtual string_type do_get_epoch(system_clock) const=0;
    virtual string_type do_get_epoch(steady_clock) const=0;
#if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS)
    virtual string_type do_get_epoch(process_real_cpu_clock) const=0;
    virtual string_type do_get_epoch(process_user_cpu_clock) const=0;
    virtual string_type do_get_epoch(process_system_cpu_clock) const=0;
    virtual string_type do_get_epoch(process_cpu_clock) const=0;
#endif
#if defined(BOOST_CHRONO_HAS_THREAD_CLOCK)
    virtual string_type do_get_epoch(thread_clock) const=0;
#endif
  };

explicit time_point_units(size_t refs = 0);

Постройте<time_point_units>грань.

Параметры:

  • refs:ссылки

Эффекты:Постройте<time_point_units>грань. Если аргумент<refs><0>, то разрушение объекта делегируется в область, или области, содержащие его. Это позволяет пользователю игнорировать проблемы управления временем жизни. С другой стороны, если<refsvis >1' тогда объект должен быть явно удален; местоимение не будет делать этого. В этом случае объект может поддерживаться в течение жизни нескольких мест.

virtual string_type get_pattern() const =0;

Возврат:шаблон, который будет использоваться по умолчанию.

template <typename Clock>
string_type get_epoch() const;

Возвращается:эпоха, связанная с часами<Clock>как<returnget_epoch_custom<CharT>(Clock(),*this);>

virtual ~time_point_units();

Уничтожить грань.

virtual string_type do_get_epoch(system_clock) const=0;

Параметры:

Возвращение:Эпоха, связанная с<system_clock>.

virtual string_type do_get_epoch(steady_clock) const=0;

Параметры:

Возвращение:Эпохальная струна, связанная с<steady_clock>.

#if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS)
    virtual string_type do_get_epoch(process_real_cpu_clock) const=0;
#endif

Параметры:

Возвращение:Эпоха, связанная с<process_real_cpu_clock>.

#if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS)
    virtual string_type do_get_epoch(process_user_cpu_clock) const=0;
#endif

Параметры:

Возвращение:Эпохальная строка, связанная с process_user_cpu_clock.

#if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS)
    virtual string_type do_get_epoch(process_system_cpu_clock) const=0;
#endif

Параметры:

Возвращение:Эпохальная строка, связанная с process_user_cpu_clock.

#if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS)
    virtual string_type do_get_epoch(process_cpu_clock) const=0;
#endif

Параметры:

Возвращение:Эпохальная строка, связанная с процессом_cpu_clock.

#if defined(BOOST_CHRONO_HAS_THREAD_CLOCK)
    virtual string_type do_get_epoch(thread_clock) const=0;
#endif

Параметры:

3337Возвращение:Эпохальная струна, связанная с<thread_clock>.

  // This class is used to define the strings for the default English
  template <typename CharT=char>
  class time_point_units_default: public time_point_units<CharT>
  {
  public:
    typedef CharT char_type; // Type of character the facet is instantiated on.
    typedef std::basic_string<char_type> string_type; // Type of character string used by member functions.
    explicit time_point_units_default(size_t refs = 0);
    ~time_point_units_default();
    /**
     * __returns the default pattern "%d%e".
     */
    string_type get_pattern() const;
  protected:
    /**
     * [param c a dummy instance of __system_clock.
     * __returns The epoch string returned by `clock_string<system_clock,CharT>::since()`.
     */
    string_type do_get_epoch(system_clock ) const;
    /**
     * [param c a dummy instance of __steady_clock.
     * __returns The epoch string returned by `clock_string<steady_clock,CharT>::since()`.
     */
    string_type do_get_epoch(steady_clock ) const;
#if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS)
    /**
     * [param c a dummy instance of __process_real_cpu_clock.
     * __returns The epoch string returned by `clock_string<process_real_cpu_clock,CharT>::since()`.
     */
    string_type do_get_epoch(process_real_cpu_clock ) const;
    /**
     * [param c a dummy instance of __process_user_cpu_clock.
     * __returns The epoch string returned by `clock_string<process_user_cpu_clock,CharT>::since()`.
     */
    string_type do_get_epoch(process_user_cpu_clock ) const;
    /**
     * [param c a dummy instance of __process_system_cpu_clock.
     * __returns The epoch string returned by `clock_string<process_system_cpu_clock,CharT>::since()`.
     */
    string_type do_get_epoch(process_system_cpu_clock ) const;
    /**
     * [param c a dummy instance of __process_cpu_clock.
     * __returns The epoch string returned by `clock_string<process_cpu_clock,CharT>::since()`.
     */
    string_type do_get_epoch(process_cpu_clock ) const;
#endif
#if defined(BOOST_CHRONO_HAS_THREAD_CLOCK)
    /**
     * [param c a dummy instance of __thread_clock.
     * __returns The epoch string returned by `clock_string<thread_clock,CharT>::since()`.
     */
    string_type do_get_epoch(thread_clock ) const;
#endif
  };
I/O Manipulators
I/O Streams Operations
namespace boost {
namespace chrono {
    // manipulators
    unspecified time_fmt(timezone tz);
    template<class CharT>
    unspecified time_fmt(timezone tz, basic_string<CharT> f);
    template<class CharT>
    unspecified time_fmt(timezone tz, const CharT* f);
    // i/o state savers
    template<typename CharT = char, typename Traits = std::char_traits<CharT> >
    struct timezone_io_saver
    {
      typedef std::basic_ios<CharT, Traits> state_type;
      typedef timezone aspect_type;
      explicit timezone_io_saver(state_type &s);
      timezone_io_saver(state_type &s, aspect_type new_value);
      ~timezone_io_saver();
      void timezone_io_saver__restore();
    };
    template<typename CharT = char, typename Traits = std::char_traits<CharT> >
    struct time_fmt_io_saver
    {
      typedef std::basic_ios<CharT, Traits> state_type;
      explicit time_fmt_io_saver(state_type &s);
      time_fmt_io_saver(state_type &s, basic_string<CharT> const& new_value);
      ~ time_fmt_io_saver();
      void restore();
    };
    // system_clock I/O
    template <class CharT, class Traits, class Duration>
      basic_ostream<CharT, Traits>&
      operator<<(basic_ostream<CharT, Traits>& os,
                 const time_point<system_clock, Duration>& tp);
    template <class CharT, class Traits, class Duration>
      basic_istream<CharT, Traits>&
      operator>>(basic_istream<CharT, Traits>& is,
                 time_point<system_clock, Duration>& tp);
    // Other Clocks I/O
    template <class CharT, class Traits, class Clock, class Duration>
        std::basic_ostream<CharT, Traits>&
        operator<<(std::basic_ostream<CharT, Traits>& os,
               const time_point<Clock, Duration>& tp);
    template <class CharT, class Traits, class Clock, class Duration>
        std::basic_istream<CharT, Traits>&
        operator>>(std::basic_istream<CharT, Traits>& is,
               time_point<Clock, Duration>& tp);
}
}

unspecified time_fmt(timezone tz);

3346Возвращение:: Неопределённый объект, который при передаче на<basic_ostream<CharT,Traits>>или<basic_istream<CharT,Traits>><s>будет иметь последствия:

set_timezone(s, tz);

template<class CharT>
  unspecified time_fmt(timezone tz, basic_string<CharT> f);
template<class CharT>
  unspecified time_fmt(timezone tz, const CharT* f);

3346Возвращение:: Неопределённый объект, который при передаче на<basic_ostream<CharT,Traits>>или<basic_istream<CharT,Traits>><s>будет иметь последствия:

set_timezone(s, tz);
set_time_fmt<CharT>(s, f);

template <class CharT, class Traits, class Duration>
    std::basic_ostream<CharT, Traits>&
    operator<<(std::basic_ostream<CharT, Traits>& os,
           const time_point<system_clock, Duration>& tp);

Эффекты:Ведет себя как отформатированная выходная функция. После построения объекта<sentry>, если<sentry>преобразуется в<true>, устанавливает локальную переменную<tz>типа<timezone>до<get_timezone(os)>. Кроме того, строка формата, полученная с<get_time_fmt>(), записывается как пара<const CharT*>. Если у потока нет временной грани, то эта пара<constCharT*>представляет собой пустой диапазон.

Затем<tp>превращается в<time_t>, а это<time_t>превращается в<tm>. Преобразование в<tm>использование<gmtime>(при наличии), если часовой пояс<utc>, иначе он использует местное время (при наличии).

Используя грань<std::time_put>, хранящуюся в<os>, этот вставщик записывает символы в поток с использованием<tm>и строки форматирования, хранящейся в гране<time_punct>, если только эта грань не отсутствовала или если она не обеспечивала пустую строку.

Если строка форматирования пуста, то выводим следующее:

Первый выход<tm>с использованием<"%F %H:%M:">

Следующий вывод a<double>, представляющий количество секунд, хранящихся в<tm>, плюс дробные секунды, представленные в<tp>. Формат должен быть<ios::fixed>, а точность должна быть достаточной для точного представления<system_clock::duration>(например, если<system_clock::period>является микро, точность должна быть достаточной для вывода шести цифр после десятичной точки). Если число секунд меньше<10>, то выходной сигнал должен быть префиксирован<'0'>.

Наконец, если<tz>является<local>, выведите<tm>, используя шаблон «%z». Прибавьте последовательность «+0000» к потоку.

Если что-то не получается, звоните<os.setstate(ios_base::failbit |ios_base::badbit)>.

Возвращение:<os>

template <class CharT, class Traits, class Duration>
    std::basic_istream<CharT, Traits>&
    operator>>(std::basic_istream<CharT, Traits>& is,
           time_point<system_clock, Duration>& tp);

Эффекты:Ведет себя как отформатированная входная функция. После построения сторожевого объекта, если сторожевой преобразуется в истинный, получает<std::time_get>грань от<is>и получает строку форматирования таким же образом, как описано для оператора вставки. Извлеките<tm>, используя поставляемую строку форматирования, или, если она пуста, по умолчанию, как описано для оператора вставки. Обратите внимание, что извлечение не использует данные<timezone>, хранящиеся в<is>для строки по умолчанию, поскольку информация<timezone>хранится в потоке.

Любой<time_point<system_clock, Duration>>вставленный, а затем извлеченный должен привести к равному<time_point<system_clock, Duration>>, за исключением любой точности, которая не была вставлена.

Пример:

void test(std::chrono::system_clock::time_point tp)
{
    std::stringstream s;
    s << tp;
    boost::chrono::system_clock::time_point tp2;
    s >> tp2;
    assert(tp == tp2);
}

Возвращение:

template <class CharT, class Traits, class Clock, class Duration>
    std::basic_ostream<CharT, Traits>&
    operator<<(std::basic_ostream<CharT, Traits>& os,
           const time_point<Clock, Duration>& tp);

Эффекты:Ведет себя как отформатированная выходная функция. После построения<sentry>объекта, если<sentry>преобразуется в<true>, вызывает<facet.put(os,os,os.fill(),tp)>, где<facet>является<time_point_put<CharT>>гранью, связанной с<os>, или новым созданным экземпляром по умолчанию<time_point_put<CharT>>гранью.

Возвращение:<os>.

Пример:

22644271279698 nanoseconds since boot

template <class CharT, class Traits, class Clock, class Duration>
    std::basic_istream<CharT, Traits>&
    operator>>(std::basic_istream<CharT, Traits>& is,
           time_point<Clock, Duration>& tp);

Выдержки<tp>из потока<is>.

Эффекты:Ведет себя как отформатированная входная функция. После построения объекта<sentry>, если<sentry>преобразуется в<true>, вызывает<facet.get(is,std::istreambuf_iterator<CharT, Traits>(), is, err, tp)>, где<facet>является<time_point_get<CharT>>гранью, связанной с<is>, или новым созданным экземпляром по умолчанию<time_point_get<CharT>>гранью.

Если что-то не получается, звоните<os.setstate(std::ios_base::failbit |std::ios_base::badbit)>.

Возвращение:<is>.

Header <boost/chrono/floor.hpp>
Header <boost/chrono/round.hpp>
Header <boost/chrono/ceil.hpp>
namespace boost { namespace chrono {
  template <class To, class Rep, class Period>
  To floor(const duration<Rep, Period>& d);
} }

Эта функция округляет данный параметр.

namespace boost { namespace chrono {
  template <class To, class Rep, class Period>
  To round(const duration<Rep, Period>& d);
} }

Эта функция округляется до ближайшего, даже на привязке данного параметра.

namespace boost { namespace chrono {
  template <class To, class Rep, class Period>
  To ceil(const duration<Rep, Period>& d);
} }

Эта функция округляет данный параметр.

Header <boost/chrono/process_cpu_clocks.hpp>
Header <boost/chrono/thread_clock.hpp>
Macro BOOST_CHRONO_HAS_PROCESS_CLOCKS
Class process_real_cpu_clock
Class process_user_cpu_clock
Class process_system_cpu_clock
Class process_cpu_clock
Template Class process_times
process_times Input/Output
duration_values Specialization for process_times<>
clock_string<process_real_cpu_clock> Specialization
clock_string<process_user_cpu_clock> Specialization
clock_string<process_system_cpu_clock> Specialization
clock_string<process_cpu_clock> Specialization
numeric_limits Specialization for process_times<>

Знание того, сколько времени занимает выполнение программы, полезно как в тестовой, так и в производственной среде. Также полезно, если такая информация о времени разбивается на реальное (настенные часы) время, время процессора, затрачиваемое пользователем, и время процессора, затрачиваемое операционной системой, обслуживающей запросы пользователей.

Часы процесса не включают время, затрачиваемое процессом ребенка.

#define BOOST_CHRONO_HAS_PROCESS_CLOCKS
namespace boost { namespace chrono {
    class process_real_cpu_clock;
    class process_user_cpu_clock;
    class process_system_cpu_clock;
    class process_cpu_clock;
    template <typename Rep>
    struct process_times;
    template <class CharT, class Traits, class Rep>
    std::basic_ostream<CharT, Traits>&
    operator<<(std::basic_ostream<CharT, Traits>& os,
            process_times<Rep> const& rhs);
    template <class CharT, class Traits, class Rep>
    std::basic_istream<CharT, Traits>&
    operator>>(std::basic_istream<CharT, Traits>& is,
            process_times<Rep> const& rhs);
    template <class Rep>
    struct duration_values<process_times<Rep> >;
    template <class CharT>
    struct clock_string<process_real_cpu_clock, CharT>;
    struct clock_string<process_user_cpu_clock, CharT>;
    struct clock_string<process_system_cpu_clock, CharT>;
    struct clock_string<process_cpu_clock, CharT>;
} }
namespace std {
    template <class Rep>
    class numeric_limits<boost::chrono::process_times<Rep> >;
}

Этот макрос определяется, поддерживает ли платформа процессные часы.

<process_real_cpu_clock>удовлетворяют требованиям<Clock>.

Класс<process_real_cpu_clock>обеспечивает доступ к реальным настенным часам процесса, т.е. к реальным часам CPU-времени процесса вызова. Процесс относительного текущего времени можно получить по телефону<process_real_cpu_clock::now()>.

class process_real_cpu_clock {
public:
    typedef nanoseconds                          duration;
    typedef duration::rep                        rep;
    typedef duration::period                     period;
    typedef chrono::time_point<process_real_cpu_clock>    time_point;
    static constexpr bool is_steady =            true;
    static time_point now(  ) noexcept;
    static time_point now( system::error_code & ec );
};

<process_user_cpu_clock>удовлетворяют требованиям<Clock>.

<process_user_cpu_clock>класс обеспечивает доступ к постоянному времени процессора пользователя процесса вызова. Процесс относительного текущего времени пользователя можно получить по телефону<process_user_cpu_clock::now()>.

class process_user_cpu_clock {
public:
    typedef nanoseconds                          duration;
    typedef duration::rep                        rep;
    typedef duration::period                     period;
    typedef chrono::time_point<process_user_cpu_clock>    time_point;
    static constexpr bool is_steady =            true;
    static time_point now(  ) noexcept;
    static time_point now( system::error_code & ec );
};

<process_system_cpu_clock>удовлетворяют требованиям<Clock>.

<process_system_cpu_clock>класс обеспечивает доступ к системе CPU-времени устойчивых часов процесса вызова. Процесс относительной системы текущего времени можно получить по телефону<process_system_cpu_clock::now()>.

class process_system_cpu_clock {
public:
    typedef nanoseconds                          duration;
    typedef duration::rep                        rep;
    typedef duration::period                     period;
    typedef chrono::time_point<process_system_cpu_clock>    time_point;
    static constexpr bool is_steady =            true;
    static time_point now(  ) noexcept;
    static time_point now( system::error_code & ec );
};

<process_cpu_clock>может рассматриваться как<tuple<process_real_cpu_clock,process_user_cpu_clock,process_system_cpu_clock>>.

<process_cpu_clock>обеспечивает тонкую обертку вокруг API времени процесса операционной системы. Для POSIX-подобных систем это функция time(), а для Windows — функция<GetProcessTimes()>.

Процесс относительно реального, пользовательского и системного времени можно получить сразу по телефону<process_clocks::now()>.

class process_cpu_clock
{
public:
    typedef process_times<nanoseconds::rep> times ;
    typedef duration<times,  nano>                  duration;
    typedef duration::rep                           rep;
    typedef duration::period                        period;
    typedef chrono::time_point<process_cpu_clock>   time_point;
    static constexpr bool is_steady =               true;
    static time_point now(  ) noexcept;
    static time_point now( system::error_code & ec );
};

Этот класс представляет собой класс<process_cpu_clock::duration>. Как таковой он должен реализовывать арифметические операторы.

template <typename Rep>
struct process_times : arithmetic<process_times<Rep>,
    multiplicative<process_times<Rep>, Rep,
    less_than_comparable<process_times<Rep> > > >
{
    Rep real;    // real (i.e wall clock) time
    Rep user;    // user cpu time
    Rep system;  // system cpu time
    times();
    times(
        process_real_cpu_clock::rep r,
        process_user_cpu_clock::rep u,
        process_system_cpu_clock::rep s);
    template <typename Rep2>
    explicit process_times(
        Rep2 r);
    template <typename Rep2>
    explicit process_times(
        process_times<Rep2> const& rhs);
    operator rep() const;
    bool operator==(process_times const& rhs);
    template <typename Rep2>
    bool operator==(process_times<Rep2> const& rhs);
    times operator+=(process_times const& rhs);
    times operator-=(process_times const& rhs);
    times operator*=(process_times const& rhs);
    times operator/=(process_times const& rhs);
    bool operator<(process_times const & rhs) const;
};

template <class CharT, class Traits, class Rep>
std::basic_ostream<CharT, Traits>&
operator<<(std::basic_ostream<CharT, Traits>& os,
        process_times<Rep> const& rhs);

Эффекты:Выведите каждую часть, разделенную на ';' и окруженную '{', '}'.

Броски:Никаких.

template <class CharT, class Traits, class Rep>
std::basic_istream<CharT, Traits>&
operator>>(std::basic_istream<CharT, Traits>& is,
        process_times<Rep> const& rhs);

Эффекты:перевешивает значение rhs, если входной поток имеет формат «{r;u;s}». В противном случае установите состояние входного потока как failbit | eofbit.

Броски:Никаких.

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

Конкретные функции<times><zero()>,<max()>и<min()>используют относительные функции для представления каждого компонента.

template <class CharT>
struct clock_string<process_real_cpu_clock, CharT>
{
    static std::basic_string<CharT> name();
    static std::basic_string<CharT> since();
};

<clock_string<>::name()>возвращает «process_real_cpu_clock».

<clock_string<>::since()>Возвращение «с момента запуска процесса»

template <class CharT>
struct clock_string<process_user_cpu_clock, CharT>
{
    static std::basic_string<CharT> name();
    static std::basic_string<CharT> since();
};

<clock_string<>::name()>возвращает «process_real_cpu_clock».

<clock_string<>::since()>Возвращение «с момента запуска процесса»

template <class CharT>
struct clock_string<process_system_cpu_clock, CharT>
{
    static std::basic_string<CharT> name();
    static std::basic_string<CharT> since();
};

<clock_string<>::name()>возвращает «process_real_cpu_clock».

<clock_string<>::since()>Возвращение «с момента запуска процесса»

template <class CharT>
struct clock_string<process_cpu_clock, CharT>
{
    static std::basic_string<CharT> name();
    static std::basic_string<CharT> since();
};

<clock_string<>::name()>возвращает «process_real_cpu_clock».

<clock_string<>::since()>Возвращение «с момента запуска процесса»

namespace std {
    template <>
    class numeric_limits<boost::chrono::process_times<Rep>> {
        typedef boost::chrono::process_times<Rep> Res;
    public:
        static const bool is_specialized = true;
        static Res min();
        static Res max();
        static Res lowest();
        static const int digits;
        static const int digits10;
        static const bool is_signed = false;
        static const bool is_integer = true;
        static const bool is_exact = true;
        static const int radix = 0;
    };
}

Специализированные функции<process_times<Rep>><min()>,<max()>и<lowest()>используют относительные функции для представления каждого компонента.

Заметки

  • <min()>возвращает кортеж мин.
  • <max()>возвращает кортеж макс.
  • <lowest()>возвращает кортеж низших.
  • <digits>— сумма (двоичных) цифр.
  • <digits10>— сумма цифр 10.
Macro BOOST_CHRONO_HAS_THREAD_CLOCK
Macro BOOST_CHRONO_THREAD_CLOCK_IS_STEADY
Class thread_clock
clock_string<thread_clock> Specialization

Знание времени, необходимого для выполнения нити, полезно как в тестовой, так и в производственной среде.

#define BOOST_CHRONO_HAS_THREAD_CLOCK
#define BOOST_CHRONO_THREAD_CLOCK_IS_STEADY
namespace boost { namespace chrono {
    class thread_clock;
    template <class CharT>
    struct clock_string<thread_clock, CharT>;
} }

Этот макрос определяется, поддерживает ли платформа резьбовые часы.

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

<thread_clock>удовлетворяют требованиям<Clock>.

<thread_clock>класс обеспечивает доступ к реальным резьбовым настенным часам, т.е. реальным CPU-часам вызывающего потока. Относительное время потока можно получить по телефону<thread_clock::now()>.

class thread_clock {
public:
    typedef nanoseconds                          duration;
    typedef duration::rep                        rep;
    typedef duration::period                     period;
    typedef chrono::time_point<thread_clock>     time_point;
    static constexpr bool is_steady =            BOOST_CHRONO_THREAD_CLOCK_IS_STEADY;
    static time_point now(  ) noexcept;
    static time_point now( system::error_code & ec );
};

#if defined(BOOST_CHRONO_HAS_THREAD_CLOCK)
template <class CharT>
struct clock_string<thread_clock, CharT>
{
    static std::basic_string<CharT> name();
    static std::basic_string<CharT> since();
};
#endif

<clock_string<>::name()>возвращает «thread_clock».

<clock_string<>::since()>Возвращение "с момента запуска потока"

Copyright © 2008 Howard Hinnant
Copyright © 2006, 2008 Beman Dawes
Copyright © 2009-2013 Vicente J. Botet Escriba

Распространяется под лицензией Boost Software License, версия 1.0. (См. сопроводительный файл LICENSE_1_0.txt или копию по адресу) http://www.boost.org/LICENSE_1_0.txt
PrevUpHomeNext

Статья Reference раздела The Boost C++ Libraries BoostBook Documentation Subset Chapter 7. Boost.Chrono 2.0.5 может быть полезна для разработчиков на c++ и boost.




Материалы статей собраны из открытых источников, владелец сайта не претендует на авторство. Там где авторство установить не удалось, материал подаётся без имени автора. В случае если Вы считаете, что Ваши права нарушены, пожалуйста, свяжитесь с владельцем сайта.


:: Главная :: Chapter 7. Boost.Chrono 2.0.5 ::

реклама
©KANSoftWare (разработка программного обеспечения, создание программ, создание интерактивных сайтов), 2007
Top.Mail.Ru

Время компиляции файла: 2024-08-30 11:47:00
2025-05-19 17:10:00/0.11976408958435/1