Заголовочный файл стандартной библиотеки <chrono> (C++11)
Материал из cppreference.com
Этот заголовок является частью библиотеки даты и времени.
Включает | |
(C++20) |
Поддержка оператора трёхстороннего сравнения |
Классы | |
Длительность | |
Определены в пространстве имён
std::chrono | |
(C++11) |
временной интервал (шаблон класса) |
(C++11) |
указывает, что duration конвертируется в duration с другим периодом тика (шаблон класса) |
(C++11) |
строит нулевое, минимальное и максимальное значения счётчика тиков заданного типа (шаблон класса) |
Удобные typedef'ы длительности | |
Определены в пространстве имён
std::chrono | |
| std::chrono::nanoseconds(C++11) | тип длительности с Period std::nano |
| std::chrono::microseconds(C++11) | тип длительности с Period std::micro |
| std::chrono::milliseconds(C++11) | тип длительности с Period std::milli |
| std::chrono::seconds(C++11) | тип длительности с Period std::ratio<1>
|
| std::chrono::minutes(C++11) | тип длительности с Period std::ratio<60>
|
| std::chrono::hours(C++11) | тип длительности с Period std::ratio<3600>
|
| std::chrono::days(C++20) | тип длительности с Period std::ratio<86400>
|
| std::chrono::weeks(C++20) | тип длительности с Period std::ratio<604800>
|
| std::chrono::months(C++20) | тип длительности с Period std::ratio<2629746>
|
| std::chrono::years(C++20) | тип длительности с Period std::ratio<31556952>
|
Временная точка | |
Определены в пространстве имён
std::chrono | |
(C++11) |
момент времени (шаблон класса) |
(C++20) |
класс свойств, определяющий, как преобразовывать моменты времени одних часов в другие (шаблон класса) |
Часы | |
Определены в пространстве имён
std::chrono | |
(C++20) |
определяет, является ли тип типом Clock (шаблон класса) (шаблонная переменная) |
(C++11) |
текущее время из общесистемных часов реального времени (класс) |
(C++11) |
монотонные часы, которые никогда не будут корректироваться (класс) |
(C++11) |
часы с самым коротким периодом такта (класс) |
(C++20) |
Clock для Всемирного Координированного Времени (UTC - Coordinated Universal Time) (класс) |
(C++20) |
Clock для Международного Атомного Времени (TAI - International Atomic Time) (класс) |
(C++20) |
Clock для времени GPS (класс) |
(C++20) |
Clock, используемый для времени файла (определение типа) |
(C++20) |
псевдочасы, представляющие местное время (класс) |
Календарь | |
Определены в пространстве имён
std::chrono | |
(C++20) |
теговый класс, указывающий на последний день или день недели в месяце (класс) |
(C++20) |
представляет день месяца (класс) |
(C++20) |
представляет месяц в году (класс) |
(C++20) |
представляет год по григорианскому календарю (класс) |
(C++20) |
представляет день недели по григорианскому календарю (класс) |
(C++20) |
представляет энный день недели месяца (класс) |
(C++20) |
представляет последний день недели месяца (класс) |
(C++20) |
представляет собой определённый день определённого месяца (класс) |
(C++20) |
представляет последний день определённого месяца (класс) |
(C++20) |
представляет энный день недели определённого месяца (класс) |
(C++20) |
представляет последний день недели определённого месяца (класс) |
(C++20) |
представляет определённый месяц определённого года (класс) |
(C++20) |
представляет конкретный год, месяц и день (класс) |
(C++20) |
представляет последний день определённого года и месяца (класс) |
(C++20) |
представляет энный день недели определённого года и месяца (класс) |
(C++20) |
представляет последний день недели определённого года и месяца (класс) |
Время суток | |
Определены в пространстве имён
std::chrono | |
(C++20) |
представляет время суток (шаблон класса) |
Часовой пояс | |
Определены в пространстве имён
std::chrono | |
(C++20) |
описывает копию базы данных часовых поясов IANA - Internet Assigned Numbers Authority (Администрация Адресного Пространства Интернет) (класс) |
(C++20) |
представляет собой связанный список tzdb (класс) |
(C++20) |
представляет часовой пояс (класс) |
(C++20) |
представляет информацию о часовом поясе в конкретный момент времени (класс) |
(C++20) |
представляет информацию о местном времени в преобразованном времени UNIX (класс) |
(C++20) |
выбирает способ разрешения неоднозначного местного времени (перечисление) |
(C++20) |
класс свойств для указателей часовых поясов, используемых zoned_time (шаблон класса) |
(C++20) |
представляет часовой пояс и момент времени (класс) |
(C++20) |
представляет альтернативное имя для часового пояса (класс) |
(C++20) |
исключение сообщающее, что местное время не существует (класс) |
(C++20) |
исключение, сообщающее, что местное время неоднозначно (класс) |
Високосная секунда | |
Определены в пространстве имён
std::chrono | |
(C++20) |
содержит информацию о вставке високосной секунды (класс) |
(C++20) |
информация о добавлении високосной секунды (класс) |
Специализации | |
Определены в пространстве имён
std | |
| специализация свойства std::common_type (специализация шаблона класса) | |
| специализация свойства std::common_type (специализация шаблона класса) | |
поддержка форматирования для duration (специализация шаблона класса) | |
поддержка форматирования для sys_time (специализация шаблона класса) | |
поддержка форматирования для utc_time (специализация шаблона класса) | |
поддержка форматирования для tai_time (специализация шаблона класса) | |
поддержка форматирования для gps_time (специализация шаблона класса) | |
поддержка форматирования для file_time (специализация шаблона класса) | |
поддержка форматирования для local_time (специализация шаблона класса) | |
поддержка форматирования для day (специализация шаблона класса) | |
поддержка форматирования для month (специализация шаблона класса) | |
поддержка форматирования для year (специализация шаблона класса) | |
поддержка форматирования для weekday (специализация шаблона класса) | |
поддержка форматирования для weekday_indexed (специализация шаблона класса) | |
поддержка форматирования для weekday_last (специализация шаблона класса) | |
поддержка форматирования для month_day (специализация шаблона класса) | |
поддержка форматирования для month_day_last (специализация шаблона класса) | |
поддержка форматирования для month_weekday (специализация шаблона класса) | |
поддержка форматирования для month_weekday_last (специализация шаблона класса) | |
поддержка форматирования для year_month (специализация шаблона класса) | |
поддержка форматирования для year_month_day (специализация шаблона класса) | |
поддержка форматирования для year_month_day_last (специализация шаблона класса) | |
поддержка форматирования для year_month_weekday (специализация шаблона класса) | |
поддержка форматирования для year_month_weekday_last (специализация шаблона класса) | |
поддержка форматирования для hh_mm_ss (специализация шаблона класса) | |
поддержка форматирования для sys_info (специализация шаблона класса) | |
поддержка форматирования для local_info (специализация шаблона класса) | |
поддержка форматирования для zoned_time (специализация шаблона класса) | |
| поддержка хэширования для std::chrono::duration (специализация шаблона класса) | |
| поддержка хэширования для std::chrono::time_point (специализация шаблона класса) | |
(C++26) |
поддержка хэширования для std::chrono::day (специализация шаблона класса) |
| поддержка хэширования для std::chrono::month (специализация шаблона класса) | |
(C++26) |
поддержка хэширования для std::chrono::year (специализация шаблона класса) |
| поддержка хэширования для std::chrono::weekday (специализация шаблона класса) | |
| поддержка хэширования для std::chrono::weekday_indexed (специализация шаблона класса) | |
| поддержка хэширования для std::chrono::weekday_last (специализация шаблона класса) | |
| поддержка хэширования для std::chrono::month_day (специализация шаблона класса) | |
| поддержка хэширования для std::chrono::month_day_last (специализация шаблона класса) | |
| поддержка хэширования для std::chrono::month_weekday (специализация шаблона класса) | |
| поддержка хэширования для std::chrono::month_weekday_last (специализация шаблона класса) | |
| поддержка хэширования для std::chrono::year_month (специализация шаблона класса) | |
| поддержка хэширования для std::chrono::year_month_day (специализация шаблона класса) | |
| поддержка хэширования для std::chrono::year_month_day_last (специализация шаблона класса) | |
| поддержка хэширования для std::chrono::year_month_weekday (специализация шаблона класса) | |
| поддержка хэширования для std::chrono::year_month_weekday_last (специализация шаблона класса) | |
| поддержка хэширования для std::chrono::zoned_time (специализация шаблона класса) | |
| поддержка хэширования для std::chrono::leap_second (специализация шаблона класса) | |
Предварительные объявления | |
Определены в заголовочном файле
<functional> | |
(C++11) |
Объект хеш-функции (шаблон класса) |
Функции | |
Длительность | |
Определены в пространстве имён
std::chrono | |
| реализует арифметические операции с duration в качестве аргументов (шаблон функции) | |
(C++11)(C++11)(удалено в C++20)(C++11)(C++11)(C++11)(C++11)(C++20) |
сравнивает два duration (шаблон функции) |
(C++11) |
преобразует duration в другой duration с другим интервалом тиков (шаблон функции) |
(C++17) |
преобразует duration в другой, округляя в меньшую сторону (шаблон функции) |
(C++17) |
преобразует duration в другой, округляя в большую сторону (шаблон функции) |
(C++17) |
преобразует duration в другой, округляя до ближайшего, или до чётного в промежуточных случаях (шаблон функции) |
(C++17) |
получает абсолютное значение duration (шаблон функции) |
Временная точка | |
Определены в пространстве имён
std::chrono | |
(C++11) |
выполняет операции сложения и вычитания, связанные с моментом времени (шаблон функции) |
(C++11)(C++11)(удалено в C++20)(C++11)(C++11)(C++11)(C++11)(C++20) |
сравнивает два момента времени (шаблон функции) |
(C++11) |
преобразует момент времени в другой момент времени на тех же часах с другой длительностью (шаблон функции) |
| преобразует time_point в другой, округляя в меньшую сторону (шаблон функции) | |
| преобразует time_point в другой, округляя в большую сторону (шаблон функции) | |
| преобразует time_point в другой, округляя до ближайшего, или до чётного в промежуточных случаях (шаблон функции) | |
| анализирует sys_time из потока в соответствии с предоставленным форматом (шаблон функции) | |
| анализирует utc_time из потока в соответствии с предоставленным форматом (шаблон функции) | |
| анализирует tai_time из потока в соответствии с предоставленным форматом (шаблон функции) | |
| анализирует gps_time из потока в соответствии с предоставленным форматом (шаблон функции) | |
| анализирует file_time из потока в соответствии с предоставленным форматом (шаблон функции) | |
| анализирует local_time из потока в соответствии с предоставленным форматом (шаблон функции) | |
(C++20) |
конвертирует моменты времени одних часов в другие (шаблон функции) |
Календарь | |
Определены в пространстве имён
std::chrono | |
(C++20) |
сравнивает два значения day (функция) |
(C++20) |
сравнивает два значения month (функция) |
(C++20) |
сравнивает два значения year (функция) |
(C++20) |
сравнивает два значения weekday (функция) |
(C++20) |
сравнивает два значения weekday_indexed (функция) |
(C++20) |
сравнивает два значения weekday_last (функция) |
(C++20) |
сравнивает два значения month_day (функция) |
(C++20) |
сравнивает два значения month_day_last (функция) |
(C++20) |
сравнивает два значения month_weekday (функция) |
(C++20) |
сравнивает два значения month_weekday_last (функция) |
(C++20) |
сравнивает два значения year_month (функция) |
(C++20) |
сравнивает два значения year_month_day (функция) |
(C++20) |
сравнивает два значения year_month_day_last (функция) |
(C++20) |
сравнивает два значения year_month_weekday (функция) |
(C++20) |
сравнивает два значения year_month_weekday_last (функция) |
(C++20) |
складывает или вычитает количество дней и day или находит разницу между двумя day (функция) |
(C++20) |
выполняет арифметические действия над month (функция) |
(C++20) |
выполняет арифметику с year (функция) |
(C++20) |
выполняет арифметические действия с weekday (функция) |
(C++20) |
выполняет арифметические действия с year_month (функция) |
(C++20) |
добавляет или вычитает year_month_day и некоторое количество лет или месяцев (функция) |
(C++20) |
добавляет или вычитает year_month_day_last и некоторое количество лет или месяцев (функция) |
(C++20) |
добавляет или вычитает year_month_weekday и некоторое количество лет или месяцев (функция) |
(C++20) |
добавляет или вычитает year_month_weekday_last и некоторое количество лет или месяцев (функция) |
(C++20) |
стандартный синтаксис для создания даты по григорианскому календарю (функция) |
Время суток | |
Определены в пространстве имён
std::chrono | |
(C++20) |
переводит время суток между 12-ти и 24-ёх часовыми форматами (функция) |
Часовой пояс | |
Определены в пространстве имён
std::chrono | |
| получает доступ к и контролирует информацию о глобальной базе данных часовых поясов (функция) | |
(C++20) |
находит часовой пояс на основе его имени (функция) |
(C++20) |
сравнивает два объекта time_zone (функция) |
(C++20) |
сравнивает два значения zoned_time (шаблон функции) |
(C++20) |
сравнивает два объекта time_zone_link (функция) |
Високосная секунда | |
Определены в пространстве имён
std::chrono | |
(C++20) |
получает информацию о добавлении високосной секунды из объекта utc_time (шаблон функции) |
сравнивает два значения leap_second или значение leap_second и std::chrono::sys_time (шаблон функции) | |
Ввод/Вывод | |
Определены в пространстве имён
std::chrono | |
(C++20) |
выполняет потоковый вывод в duration (шаблон функции) |
| выполняет потоковый вывод sys_time (шаблон функции) | |
| выполняет потоковый вывод utc_time (шаблон функции) | |
| выполняет потоковый вывод tai_time (шаблон функции) | |
| выполняет потоковый вывод gps_time (шаблон функции) | |
| выполняет потоковый вывод file_time (шаблон функции) | |
(C++20) |
выводит day в поток (шаблон функции) |
(C++20) |
выводит month в поток (шаблон функции) |
(C++20) |
выводит year в поток (шаблон функции) |
(C++20) |
выводит weekday в поток (шаблон функции) |
(C++20) |
выводит weekday_indexed в поток (шаблон функции) |
(C++20) |
выводит weekday_last в поток (шаблон функции) |
(C++20) |
выводит month_day в поток (шаблон функции) |
(C++20) |
выводит month_day_last в поток (шаблон функции) |
(C++20) |
выводит month_weekday в поток (шаблон функции) |
(C++20) |
выводит month_weekday_last в поток (шаблон функции) |
(C++20) |
выводит year_month в поток (шаблон функции) |
(C++20) |
выводит year_month_day в поток (шаблон функции) |
(C++20) |
выводит year_month_day_last в поток (шаблон функции) |
(C++20) |
выводит year_month_weekday в поток (шаблон функции) |
(C++20) |
выводит year_month_weekday_last в поток (шаблон функции) |
(C++20) |
выводит hh_mm_ss в поток (шаблон функции) |
(C++20) |
выводит sys_info в поток (шаблон функции) |
(C++20) |
выводит local_info в поток (шаблон функции) |
(C++20) |
выводит zoned_time в поток (шаблон функции) |
(C++20) |
разбирает day из потока в соответствии с предоставленным форматом (шаблон функции) |
(C++20) |
разбирает month из потока в соответствии с предоставленным форматом (шаблон функции) |
(C++20) |
разбирает year из потока в соответствии с предоставленным форматом (шаблон функции) |
(C++20) |
разбирает weekday из потока в соответствии с предоставленным форматом (шаблон функции) |
(C++20) |
анализирует month_day из потока в соответствии с предоставленным форматом (шаблон функции) |
(C++20) |
разбирает year_month из потока в соответствии с предоставленным форматом (шаблон функции) |
(C++20) |
разбирает year_month_day из потока в соответствии с предоставленным форматом (шаблон функции) |
(C++20) |
разбирает объект chrono из потока (шаблон функции) |
Литералы | |
Определены в пространстве имён
std::literals::chrono_literals | |
(C++14) |
Литерал std::chrono::duration, представляющий часы (функция) |
(C++14) |
Литерал std::chrono::duration, представляющий минуты (функция) |
(C++14) |
Литерал std::chrono::duration, представляющий секунды (функция) |
(C++14) |
Литерал std::chrono::duration, представляющий миллисекунды (функция) |
(C++14) |
Литерал std::chrono::duration, представляющий микросекунды (функция) |
(C++14) |
Литерал std::chrono::duration, представляющий наносекунды (функция) |
(C++20) |
Литерал std::chrono::day, представляющий день месяца (функция) |
(C++20) |
Литерал std::chrono::year, представляющий конкретный год (функция) |
Резюме
#include <compare>
namespace std {
namespace chrono {
// шаблонный класс duration
template<class Rep, class Period = ratio<1>> class duration;
// шаблонный класс time_point
template<class Clock, class Duration = typename Clock::duration> class time_point;
}
// специализации common_type
template<class Rep1, class Period1, class Rep2, class Period2>
struct common_type<chrono::duration<Rep1, Period1>,
chrono::duration<Rep2, Period2>>;
template<class Clock, class Duration1, class Duration2>
struct common_type<chrono::time_point<Clock, Duration1>,
chrono::time_point<Clock, Duration2>>;
namespace chrono {
// настройка свойств
template<class Rep> struct treat_as_floating_point;
template<class Rep>
inline constexpr bool treat_as_floating_point_v = treat_as_floating_point<Rep>::value;
template<class Rep> struct duration_values;
template<class T> struct is_clock;
template<class T> inline constexpr bool is_clock_v = is_clock<T>::value;
// арифметика duration
template<class Rep1, class Period1, class Rep2, class Period2>
constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
template<class Rep1, class Period1, class Rep2, class Period2>
constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
template<class Rep1, class Period, class Rep2>
constexpr duration<common_type_t<Rep1, Rep2>, Period>
operator*(const duration<Rep1, Period>& d, const Rep2& s);
template<class Rep1, class Rep2, class Period>
constexpr duration<common_type_t<Rep1, Rep2>, Period>
operator*(const Rep1& s, const duration<Rep2, Period>& d);
template<class Rep1, class Period, class Rep2>
constexpr duration<common_type_t<Rep1, Rep2>, Period>
operator/(const duration<Rep1, Period>& d, const Rep2& s);
template<class Rep1, class Period1, class Rep2, class Period2>
constexpr common_type_t<Rep1, Rep2>
operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
template<class Rep1, class Period, class Rep2>
constexpr duration<common_type_t<Rep1, Rep2>, Period>
operator%(const duration<Rep1, Period>& d, const Rep2& s);
template<class Rep1, class Period1, class Rep2, class Period2>
constexpr common_type_t<duration<Rep1, Period1>, duration<Rep2, Period2>>
operator%(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
// сравнения duration
template<class Rep1, class Period1, class Rep2, class Period2>
constexpr bool operator==(const duration<Rep1, Period1>& lhs,
const duration<Rep2, Period2>& rhs);
template<class Rep1, class Period1, class Rep2, class Period2>
constexpr bool operator< (const duration<Rep1, Period1>& lhs,
const duration<Rep2, Period2>& rhs);
template<class Rep1, class Period1, class Rep2, class Period2>
constexpr bool operator> (const duration<Rep1, Period1>& lhs,
const duration<Rep2, Period2>& rhs);
template<class Rep1, class Period1, class Rep2, class Period2>
constexpr bool operator<=(const duration<Rep1, Period1>& lhs,
const duration<Rep2, Period2>& rhs);
template<class Rep1, class Period1, class Rep2, class Period2>
constexpr bool operator>=(const duration<Rep1, Period1>& lhs,
const duration<Rep2, Period2>& rhs);
template<class Rep1, class Period1, class Rep2, class Period2>
requires /* смотрите описание */
constexpr auto operator<=>(const duration<Rep1, Period1>& lhs,
const duration<Rep2, Period2>& rhs);
// преобразования
template<class ToDuration, class Rep, class Period>
constexpr ToDuration duration_cast(const duration<Rep, Period>& d);
template<class ToDuration, class Rep, class Period>
constexpr ToDuration floor(const duration<Rep, Period>& d);
template<class ToDuration, class Rep, class Period>
constexpr ToDuration ceil(const duration<Rep, Period>& d);
template<class ToDuration, class Rep, class Period>
constexpr ToDuration round(const duration<Rep, Period>& d);
// duration Ввод/Вывод
template<class CharT, class Traits, class Rep, class Period>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os,
const duration<Rep, Period>& d);
template<class CharT, class Traits, class Rep, class Period, class Alloc = allocator<CharT>>
basic_istream<CharT, Traits>&
from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
duration<Rep, Period>& d,
basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
minutes* offset = nullptr);
// удобные typedef'ы
using nanoseconds = duration</* целочисленный тип со знаком не менее 64 бит */, nano>;
using microseconds = duration</* целочисленный тип со знаком не менее 55 бит */, micro>;
using milliseconds = duration</* целочисленный тип со знаком не менее 45 бит */, milli>;
using seconds = duration</* целочисленный тип со знаком не менее 35 бит */>;
using minutes = duration</* целочисленный тип со знаком не менее 29 бит */,
ratio< 60>>;
using hours = duration</* целочисленный тип со знаком не менее 23 бит */,
ratio<3600>>;
using days = duration</* целочисленный тип со знаком не менее 25 бит */,
ratio_multiply<ratio<24>, hours::period>>;
using weeks = duration</* целочисленный тип со знаком не менее 22 бит */,
ratio_multiply<ratio<7>, days::period>>;
using years = duration</* целочисленный тип со знаком не менее 17 бит */,
ratio_multiply<ratio<146097, 400>, days::period>>;
using months = duration</* целочисленный тип со знаком не менее 20 бит */,
ratio_divide<years::period, ratio<12>>>;
// арифметика time_point
template<class Clock, class Duration1, class Rep2, class Period2>
constexpr time_point<Clock, common_type_t<Duration1, duration<Rep2, Period2>>>
operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
template<class Rep1, class Period1, class Clock, class Duration2>
constexpr time_point<Clock, common_type_t<duration<Rep1, Period1>, Duration2>>
operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);
template<class Clock, class Duration1, class Rep2, class Period2>
constexpr time_point<Clock, common_type_t<Duration1, duration<Rep2, Period2>>>
operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
template<class Clock, class Duration1, class Duration2>
constexpr common_type_t<Duration1, Duration2>
operator-(const time_point<Clock, Duration1>& lhs,
const time_point<Clock, Duration2>& rhs);
// сравнения time_point
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, three_way_comparable_with<Duration1> Duration2>
constexpr auto operator<=>(const time_point<Clock, Duration1>& lhs,
const time_point<Clock, Duration2>& rhs);
// преобразования
template<class ToDuration, class Clock, class Duration>
constexpr time_point<Clock, ToDuration>
time_point_cast(const time_point<Clock, Duration>& t);
template<class ToDuration, class Clock, class Duration>
constexpr time_point<Clock, ToDuration> floor(const time_point<Clock, Duration>& tp);
template<class ToDuration, class Clock, class Duration>
constexpr time_point<Clock, ToDuration> ceil(const time_point<Clock, Duration>& tp);
template<class ToDuration, class Clock, class Duration>
constexpr time_point<Clock, ToDuration> round(const time_point<Clock, Duration>& tp);
// специализированные алгоритмы
template<class Rep, class Period>
constexpr duration<Rep, Period> abs(duration<Rep, Period> d);
// класс system_clock
class system_clock;
template<class Duration>
using sys_time = time_point<system_clock, Duration>;
using sys_seconds = sys_time<seconds>;
using sys_days = sys_time<days>;
template<class CharT, class Traits, class Duration>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const sys_time<Duration>& tp);
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const sys_days& dp);
template<class CharT, class Traits, class Duration, class Alloc = allocator<CharT>>
basic_istream<CharT, Traits>&
from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
sys_time<Duration>& tp,
basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
minutes* offset = nullptr);
// класс utc_clock
class utc_clock;
template<class Duration>
using utc_time = time_point<utc_clock, Duration>;
using utc_seconds = utc_time<seconds>;
template<class CharT, class Traits, class Duration>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const utc_time<Duration>& t);
template<class CharT, class Traits, class Duration, class Alloc = allocator<CharT>>
basic_istream<CharT, Traits>&
from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
utc_time<Duration>& tp,
basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
minutes* offset = nullptr);
struct leap_second_info;
template<class Duration>
leap_second_info get_leap_second_info(const utc_time<Duration>& ut);
// класс tai_clock
class tai_clock;
template<class Duration>
using tai_time = time_point<tai_clock, Duration>;
using tai_seconds = tai_time<seconds>;
template<class CharT, class Traits, class Duration>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const tai_time<Duration>& t);
template<class CharT, class Traits, class Duration, class Alloc = allocator<CharT>>
basic_istream<CharT, Traits>&
from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
tai_time<Duration>& tp,
basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
minutes* offset = nullptr);
// класс gps_clock
class gps_clock;
template<class Duration>
using gps_time = time_point<gps_clock, Duration>;
using gps_seconds = gps_time<seconds>;
template<class CharT, class Traits, class Duration>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const gps_time<Duration>& t);
template<class CharT, class Traits, class Duration, class Alloc = allocator<CharT>>
basic_istream<CharT, Traits>&
from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
gps_time<Duration>& tp,
basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
minutes* offset = nullptr);
// тип file_clock
using file_clock = /* смотрите описание */;
template<class Duration>
using file_time = time_point<file_clock, Duration>;
template<class CharT, class Traits, class Duration>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const file_time<Duration>& tp);
template<class CharT, class Traits, class Duration, class Alloc = allocator<CharT>>
basic_istream<CharT, Traits>&
from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
file_time<Duration>& tp,
basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
minutes* offset = nullptr);
// класс steady_clock
class steady_clock;
// класс high_resolution_clock
class high_resolution_clock;
// местное время
struct local_t {};
template<class Duration>
using local_time = time_point<local_t, Duration>;
using local_seconds = local_time<seconds>;
using local_days = local_time<days>;
template<class CharT, class Traits, class Duration>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const local_time<Duration>& tp);
template<class CharT, class Traits, class Duration, class Alloc = allocator<CharT>>
basic_istream<CharT, Traits>&
from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
local_time<Duration>& tp,
basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
minutes* offset = nullptr);
// преобразования time_point
template<class DestClock, class SourceClock>
struct clock_time_conversion;
template<class DestClock, class SourceClock, class Duration>
auto clock_cast(const time_point<SourceClock, Duration>& t);
// класс last_spec
struct last_spec;
// класс day
class day;
constexpr bool operator==(const day& x, const day& y) noexcept;
constexpr strong_ordering operator<=>(const day& x, const day& y) noexcept;
constexpr day operator+(const day& x, const days& y) noexcept;
constexpr day operator+(const days& x, const day& y) noexcept;
constexpr day operator-(const day& x, const days& y) noexcept;
constexpr days operator-(const day& x, const day& y) noexcept;
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const day& d);
template<class CharT, class Traits, class Alloc = allocator<CharT>>
basic_istream<CharT, Traits>&
from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
day& d, basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
minutes* offset = nullptr);
// класс month
class month;
constexpr bool operator==(const month& x, const month& y) noexcept;
constexpr strong_ordering operator<=>(const month& x, const month& y) noexcept;
constexpr month operator+(const month& x, const months& y) noexcept;
constexpr month operator+(const months& x, const month& y) noexcept;
constexpr month operator-(const month& x, const months& y) noexcept;
constexpr months operator-(const month& x, const month& y) noexcept;
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const month& m);
template<class CharT, class Traits, class Alloc = allocator<CharT>>
basic_istream<CharT, Traits>&
from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
month& m, basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
minutes* offset = nullptr);
// класс year
class year;
constexpr bool operator==(const year& x, const year& y) noexcept;
constexpr strong_ordering operator<=>(const year& x, const year& y) noexcept;
constexpr year operator+(const year& x, const years& y) noexcept;
constexpr year operator+(const years& x, const year& y) noexcept;
constexpr year operator-(const year& x, const years& y) noexcept;
constexpr years operator-(const year& x, const year& y) noexcept;
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const year& y);
template<class CharT, class Traits, class Alloc = allocator<CharT>>
basic_istream<CharT, Traits>&
from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
year& y, basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
minutes* offset = nullptr);
// класс weekday
class weekday;
constexpr bool operator==(const weekday& x, const weekday& y) noexcept;
constexpr weekday operator+(const weekday& x, const days& y) noexcept;
constexpr weekday operator+(const days& x, const weekday& y) noexcept;
constexpr weekday operator-(const weekday& x, const days& y) noexcept;
constexpr days operator-(const weekday& x, const weekday& y) noexcept;
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const weekday& wd);
template<class CharT, class Traits, class Alloc = allocator<CharT>>
basic_istream<CharT, Traits>&
from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
weekday& wd, basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
minutes* offset = nullptr);
// класс weekday_indexed
class weekday_indexed;
constexpr bool operator==(const weekday_indexed& x, const weekday_indexed& y) noexcept;
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const weekday_indexed& wdi);
// класс weekday_last
class weekday_last;
constexpr bool operator==(const weekday_last& x, const weekday_last& y) noexcept;
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const weekday_last& wdl);
// класс month_day
class month_day;
constexpr bool operator==(const month_day& x, const month_day& y) noexcept;
constexpr strong_ordering operator<=>(const month_day& x, const month_day& y) noexcept;
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const month_day& md);
template<class CharT, class Traits, class Alloc = allocator<CharT>>
basic_istream<CharT, Traits>&
from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
month_day& md, basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
minutes* offset = nullptr);
// класс month_day_last
class month_day_last;
constexpr bool operator==(const month_day_last& x, const month_day_last& y) noexcept;
constexpr strong_ordering operator<=>(const month_day_last& x,
const month_day_last& y) noexcept;
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const month_day_last& mdl);
// класс month_weekday
class month_weekday;
constexpr bool operator==(const month_weekday& x, const month_weekday& y) noexcept;
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const month_weekday& mwd);
// класс month_weekday_last
class month_weekday_last;
constexpr bool operator==(const month_weekday_last& x, const month_weekday_last& y) noexcept;
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const month_weekday_last& mwdl);
// класс year_month
class year_month;
constexpr bool operator==(const year_month& x, const year_month& y) noexcept;
constexpr strong_ordering operator<=>(const year_month& x, const year_month& y) noexcept;
constexpr year_month operator+(const year_month& ym, const months& dm) noexcept;
constexpr year_month operator+(const months& dm, const year_month& ym) noexcept;
constexpr year_month operator-(const year_month& ym, const months& dm) noexcept;
constexpr months operator-(const year_month& x, const year_month& y) noexcept;
constexpr year_month operator+(const year_month& ym, const years& dy) noexcept;
constexpr year_month operator+(const years& dy, const year_month& ym) noexcept;
constexpr year_month operator-(const year_month& ym, const years& dy) noexcept;
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const year_month& ym);
template<class CharT, class Traits, class Alloc = allocator<CharT>>
basic_istream<CharT, Traits>&
from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
year_month& ym, basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
minutes* offset = nullptr);
// класс year_month_day
class year_month_day;
constexpr bool operator==(const year_month_day& x, const year_month_day& y) noexcept;
constexpr strong_ordering operator<=>(const year_month_day& x,
const year_month_day& y) noexcept;
constexpr year_month_day operator+(const year_month_day& ymd, const months& dm) noexcept;
constexpr year_month_day operator+(const months& dm, const year_month_day& ymd) noexcept;
constexpr year_month_day operator+(const year_month_day& ymd, const years& dy) noexcept;
constexpr year_month_day operator+(const years& dy, const year_month_day& ymd) noexcept;
constexpr year_month_day operator-(const year_month_day& ymd, const months& dm) noexcept;
constexpr year_month_day operator-(const year_month_day& ymd, const years& dy) noexcept;
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const year_month_day& ymd);
template<class CharT, class Traits, class Alloc = allocator<CharT>>
basic_istream<CharT, Traits>&
from_stream(basic_istream<CharT, Traits>& is, const CharT* fmt,
year_month_day& ymd,
basic_string<CharT, Traits, Alloc>* abbrev = nullptr,
minutes* offset = nullptr);
// класс year_month_day_last
class year_month_day_last;
constexpr bool operator==(const year_month_day_last& x,
const year_month_day_last& y) noexcept;
constexpr strong_ordering operator<=>(const year_month_day_last& x,
const year_month_day_last& y) noexcept;
constexpr year_month_day_last
operator+(const year_month_day_last& ymdl, const months& dm) noexcept;
constexpr year_month_day_last
operator+(const months& dm, const year_month_day_last& ymdl) noexcept;
constexpr year_month_day_last
operator+(const year_month_day_last& ymdl, const years& dy) noexcept;
constexpr year_month_day_last
operator+(const years& dy, const year_month_day_last& ymdl) noexcept;
constexpr year_month_day_last
operator-(const year_month_day_last& ymdl, const months& dm) noexcept;
constexpr year_month_day_last
operator-(const year_month_day_last& ymdl, const years& dy) noexcept;
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const year_month_day_last& ymdl);
// класс year_month_weekday
class year_month_weekday;
constexpr bool operator==(const year_month_weekday& x,
const year_month_weekday& y) noexcept;
constexpr year_month_weekday
operator+(const year_month_weekday& ymwd, const months& dm) noexcept;
constexpr year_month_weekday
operator+(const months& dm, const year_month_weekday& ymwd) noexcept;
constexpr year_month_weekday
operator+(const year_month_weekday& ymwd, const years& dy) noexcept;
constexpr year_month_weekday
operator+(const years& dy, const year_month_weekday& ymwd) noexcept;
constexpr year_month_weekday
operator-(const year_month_weekday& ymwd, const months& dm) noexcept;
constexpr year_month_weekday
operator-(const year_month_weekday& ymwd, const years& dy) noexcept;
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const year_month_weekday& ymwdi);
// класс year_month_weekday_last
class year_month_weekday_last;
constexpr bool operator==(const year_month_weekday_last& x,
const year_month_weekday_last& y) noexcept;
constexpr year_month_weekday_last
operator+(const year_month_weekday_last& ymwdl, const months& dm) noexcept;
constexpr year_month_weekday_last
operator+(const months& dm, const year_month_weekday_last& ymwdl) noexcept;
constexpr year_month_weekday_last
operator+(const year_month_weekday_last& ymwdl, const years& dy) noexcept;
constexpr year_month_weekday_last
operator+(const years& dy, const year_month_weekday_last& ymwdl) noexcept;
constexpr year_month_weekday_last
operator-(const year_month_weekday_last& ymwdl, const months& dm) noexcept;
constexpr year_month_weekday_last
operator-(const year_month_weekday_last& ymwdl, const years& dy) noexcept;
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const year_month_weekday_last& ymwdl);
// операторы обычного синтаксиса гражданского календаря
constexpr year_month
operator/(const year& y, const month& m) noexcept;
constexpr year_month
operator/(const year& y, int m) noexcept;
constexpr month_day
operator/(const month& m, const day& d) noexcept;
constexpr month_day
operator/(const month& m, int d) noexcept;
constexpr month_day
operator/(int m, const day& d) noexcept;
constexpr month_day
operator/(const day& d, const month& m) noexcept;
constexpr month_day
operator/(const day& d, int m) noexcept;
constexpr month_day_last
operator/(const month& m, last_spec) noexcept;
constexpr month_day_last
operator/(int m, last_spec) noexcept;
constexpr month_day_last
operator/(last_spec, const month& m) noexcept;
constexpr month_day_last
operator/(last_spec, int m) noexcept;
constexpr month_weekday
operator/(const month& m, const weekday_indexed& wdi) noexcept;
constexpr month_weekday
operator/(int m, const weekday_indexed& wdi) noexcept;
constexpr month_weekday
operator/(const weekday_indexed& wdi, const month& m) noexcept;
constexpr month_weekday
operator/(const weekday_indexed& wdi, int m) noexcept;
constexpr month_weekday_last
operator/(const month& m, const weekday_last& wdl) noexcept;
constexpr month_weekday_last
operator/(int m, const weekday_last& wdl) noexcept;
constexpr month_weekday_last
operator/(const weekday_last& wdl, const month& m) noexcept;
constexpr month_weekday_last
operator/(const weekday_last& wdl, int m) noexcept;
constexpr year_month_day
operator/(const year_month& ym, const day& d) noexcept;
constexpr year_month_day
operator/(const year_month& ym, int d) noexcept;
constexpr year_month_day
operator/(const year& y, const month_day& md) noexcept;
constexpr year_month_day
operator/(int y, const month_day& md) noexcept;
constexpr year_month_day
operator/(const month_day& md, const year& y) noexcept;
constexpr year_month_day
operator/(const month_day& md, int y) noexcept;
constexpr year_month_day_last
operator/(const year_month& ym, last_spec) noexcept;
constexpr year_month_day_last
operator/(const year& y, const month_day_last& mdl) noexcept;
constexpr year_month_day_last
operator/(int y, const month_day_last& mdl) noexcept;
constexpr year_month_day_last
operator/(const month_day_last& mdl, const year& y) noexcept;
constexpr year_month_day_last
operator/(const month_day_last& mdl, int y) noexcept;
constexpr year_month_weekday
operator/(const year_month& ym, const weekday_indexed& wdi) noexcept;
constexpr year_month_weekday
operator/(const year& y, const month_weekday& mwd) noexcept;
constexpr year_month_weekday
operator/(int y, const month_weekday& mwd) noexcept;
constexpr year_month_weekday
operator/(const month_weekday& mwd, const year& y) noexcept;
constexpr year_month_weekday
operator/(const month_weekday& mwd, int y) noexcept;
constexpr year_month_weekday_last
operator/(const year_month& ym, const weekday_last& wdl) noexcept;
constexpr year_month_weekday_last
operator/(const year& y, const month_weekday_last& mwdl) noexcept;
constexpr year_month_weekday_last
operator/(int y, const month_weekday_last& mwdl) noexcept;
constexpr year_month_weekday_last
operator/(const month_weekday_last& mwdl, const year& y) noexcept;
constexpr year_month_weekday_last
operator/(const month_weekday_last& mwdl, int y) noexcept;
// шаблонный класс hh_mm_ss
template<class Duration> class hh_mm_ss;
template<class CharT, class Traits, class Duration>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const hh_mm_ss<Duration>& hms);
// 12/24-часовые функции
constexpr bool is_am(const hours& h) noexcept;
constexpr bool is_pm(const hours& h) noexcept;
constexpr hours make12(const hours& h) noexcept;
constexpr hours make24(const hours& h, bool is_pm) noexcept;
// база данных часовых поясов
struct tzdb;
class tzdb_list;
// доступ к базе данных часовых поясов
const tzdb& get_tzdb();
tzdb_list& get_tzdb_list();
const time_zone* locate_zone(string_view tz_name);
const time_zone* current_zone();
// поддержка удалённой базы данных часовых поясов
const tzdb& reload_tzdb();
string remote_version();
// классы исключений
class nonexistent_local_time;
class ambiguous_local_time;
// информационные классы
struct sys_info;
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const sys_info& si);
struct local_info;
template<class CharT, class Traits>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os, const local_info& li);
// класс time_zone
enum class choose {earliest, latest};
class time_zone;
bool operator==(const time_zone& x, const time_zone& y) noexcept;
strong_ordering operator<=>(const time_zone& x, const time_zone& y) noexcept;
// класс template zoned_traits
template<class T> struct zoned_traits;
// класс template zoned_time
template<class Duration, class TimeZonePtr = const time_zone*> class zoned_time;
using zoned_seconds = zoned_time<seconds>;
template<class Duration1, class Duration2, class TimeZonePtr>
bool operator==(const zoned_time<Duration1, TimeZonePtr>& x,
const zoned_time<Duration2, TimeZonePtr>& y);
template<class CharT, class Traits, class Duration, class TimeZonePtr>
basic_ostream<CharT, Traits>&
operator<<(basic_ostream<CharT, Traits>& os,
const zoned_time<Duration, TimeZonePtr>& t);
// поддержка весакосной секунды
class leap_second;
bool operator==(const leap_second& x, const leap_second& y);
strong_ordering operator<=>(const leap_second& x, const leap_second& y);
template<class Duration>
constexpr bool operator==(const leap_second& x, const sys_time<Duration>& y);
template<class Duration>
constexpr bool operator< (const leap_second& x, const sys_time<Duration>& y);
template<class Duration>
constexpr bool operator< (const sys_time<Duration>& x, const leap_second& y);
template<class Duration>
constexpr bool operator> (const leap_second& x, const sys_time<Duration>& y);
template<class Duration>
constexpr bool operator> (const sys_time<Duration>& x, const leap_second& y);
template<class Duration>
constexpr bool operator<=(const leap_second& x, const sys_time<Duration>& y);
template<class Duration>
constexpr bool operator<=(const sys_time<Duration>& x, const leap_second& y);
template<class Duration>
constexpr bool operator>=(const leap_second& x, const sys_time<Duration>& y);
template<class Duration>
constexpr bool operator>=(const sys_time<Duration>& x, const leap_second& y);
template<class Duration>
requires three_way_comparable_with<sys_seconds, sys_time<Duration>>
constexpr auto operator<=>(const leap_second& x, const sys_time<Duration>& y);
// класс time_zone_link
class time_zone_link;
bool operator==(const time_zone_link& x, const time_zone_link& y);
strong_ordering operator<=>(const time_zone_link& x, const time_zone_link& y);
// форматирование
template<class Duration> struct /*local-time-format-t*/; // только экспозиция
template<class Duration>
/*local-time-format-t*/<Duration>
local_time_format(local_time<Duration> time, const string* abbrev = nullptr,
const seconds* offset_sec = nullptr);
}
template<class Rep, class Period, class CharT>
struct formatter<chrono::duration<Rep, Period>, CharT>;
template<class Duration, class CharT>
struct formatter<chrono::sys_time<Duration>, CharT>;
template<class Duration, class CharT>
struct formatter<chrono::utc_time<Duration>, CharT>;
template<class Duration, class CharT>
struct formatter<chrono::tai_time<Duration>, CharT>;
template<class Duration, class CharT>
struct formatter<chrono::gps_time<Duration>, CharT>;
template<class Duration, class CharT>
struct formatter<chrono::file_time<Duration>, CharT>;
template<class Duration, class CharT>
struct formatter<chrono::local_time<Duration>, CharT>;
template<class Duration, class CharT>
struct formatter<chrono::/*local-time-format-t*/<Duration>, CharT>;
template<class CharT> struct formatter<chrono::day, CharT>;
template<class CharT> struct formatter<chrono::month, CharT>;
template<class CharT> struct formatter<chrono::year, CharT>;
template<class CharT> struct formatter<chrono::weekday, CharT>;
template<class CharT> struct formatter<chrono::weekday_indexed, CharT>;
template<class CharT> struct formatter<chrono::weekday_last, CharT>;
template<class CharT> struct formatter<chrono::month_day, CharT>;
template<class CharT> struct formatter<chrono::month_day_last, CharT>;
template<class CharT> struct formatter<chrono::month_weekday, CharT>;
template<class CharT> struct formatter<chrono::month_weekday_last, CharT>;
template<class CharT> struct formatter<chrono::year_month, CharT>;
template<class CharT> struct formatter<chrono::year_month_day, CharT>;
template<class CharT> struct formatter<chrono::year_month_day_last, CharT>;
template<class CharT> struct formatter<chrono::year_month_weekday, CharT>;
template<class CharT> struct formatter<chrono::year_month_weekday_last, CharT>;
template<class Rep, class Period, class CharT>
struct formatter<chrono::hh_mm_ss<duration<Rep, Period>>, CharT>;
template<class CharT> struct formatter<chrono::sys_info, CharT>;
template<class CharT> struct formatter<chrono::local_info, CharT>;
template<class Duration, class TimeZonePtr, class CharT>
struct formatter<chrono::zoned_time<Duration, TimeZonePtr>, CharT>;
namespace chrono {
// разбор
template<class CharT, class Parsable>
/* не указано */
parse(const CharT* fmt, Parsable& tp);
template<class CharT, class Traits, class Alloc, class Parsable>
/* не указано */
parse(const basic_string<CharT, Traits, Alloc>& format, Parsable& tp);
template<class CharT, class traits, class Alloc, class Parsable>
/* не указано */
parse(const CharT* fmt, Parsable& tp,
basic_string<CharT, traits, Alloc>& abbrev);
template<class CharT, class Traits, class Alloc, class Parsable>
/* не указано */
parse(const basic_string<CharT, Traits, Alloc>& format, Parsable& tp,
basic_string<CharT, Traits, Alloc>& abbrev);
template<class CharT, class Parsable>
/* не указано */
parse(const CharT* fmt, Parsable& tp, minutes& offset);
template<class CharT, class Traits, class Alloc, class Parsable>
/* не указано */
parse(const basic_string<CharT, Traits, Alloc>& format, Parsable& tp,
minutes& offset);
template<class CharT, class traits, class Alloc, class Parsable>
/* не указано */
parse(const CharT* fmt, Parsable& tp,
basic_string<CharT, traits, Alloc>& abbrev, minutes& offset);
template<class CharT, class Traits, class Alloc, class Parsable>
/* не указано */
parse(const basic_string<CharT, Traits, Alloc>& format, Parsable& tp,
basic_string<CharT, Traits, Alloc>& abbrev, minutes& offset);
// календарные константы
inline constexpr last_spec last{};
inline constexpr weekday Sunday{0};
inline constexpr weekday Monday{1};
inline constexpr weekday Tuesday{2};
inline constexpr weekday Wednesday{3};
inline constexpr weekday Thursday{4};
inline constexpr weekday Friday{5};
inline constexpr weekday Saturday{6};
inline constexpr month January{1};
inline constexpr month February{2};
inline constexpr month March{3};
inline constexpr month April{4};
inline constexpr month May{5};
inline constexpr month June{6};
inline constexpr month July{7};
inline constexpr month August{8};
inline constexpr month September{9};
inline constexpr month October{10};
inline constexpr month November{11};
inline constexpr month December{12};
}
inline namespace literals {
inline namespace chrono_literals {
// суффиксы для литералов длительности
constexpr chrono::hours operator""h(unsigned long long);
constexpr chrono::duration</* не указано */,
ratio<3600, 1>> operator""h(long double);
constexpr chrono::minutes operator""min(unsigned long long);
constexpr chrono::duration</* не указано */,
ratio<60, 1>> operator""min(long double);
constexpr chrono::seconds operator""s(unsigned long long);
constexpr chrono::duration</* не указано */> operator""s(long double);
constexpr chrono::milliseconds operator""ms(unsigned long long);
constexpr chrono::duration</* не указано */, milli> operator""ms(long double);
constexpr chrono::microseconds operator""us(unsigned long long);
constexpr chrono::duration</* не указано */, micro> operator""us(long double);
constexpr chrono::nanoseconds operator""ns(unsigned long long);
constexpr chrono::duration</* не указано */, nano> operator""ns(long double);
// non-member functions
constexpr chrono::day operator""d(unsigned long long d) noexcept;
// non-member functions
constexpr chrono::year operator""y(unsigned long long y) noexcept;
}
}
namespace chrono {
using namespace literals::chrono_literals;
}
// поддержка хэширования
template<class T> struct hash;
template<class Rep, class Period>
struct hash<chrono::duration<Rep, Period>>;
template<class Clock, class Duration>
struct hash<chrono::time_point<Clock, Duration>>;
template<> struct hash<chrono::day>;
template<> struct hash<chrono::month>;
template<> struct hash<chrono::year>;
template<> struct hash<chrono::weekday>;
template<> struct hash<chrono::weekday_indexed>;
template<> struct hash<chrono::weekday_last>;
template<> struct hash<chrono::month_day>;
template<> struct hash<chrono::month_day_last>;
template<> struct hash<chrono::month_weekday>;
template<> struct hash<chrono::month_weekday_last>;
template<> struct hash<chrono::year_month>;
template<> struct hash<chrono::year_month_day>;
template<> struct hash<chrono::year_month_day_last>;
template<> struct hash<chrono::year_month_weekday>;
template<> struct hash<chrono::year_month_weekday_last>;
template<class Duration, class TimeZonePtr>
struct hash<chrono::zoned_time<Duration, TimeZonePtr>>;
template<> struct hash<chrono::leap_second>;
}
Шаблонный класс std::chrono::duration
namespace std::chrono {
template<class Rep, class Period = ratio<1>>
class duration {
public:
using rep = Rep;
using period = typename Period::type;
private:
rep rep_; // только экспозиция
public:
// создание/копирование/уничтожение
constexpr duration() = default;
template<class Rep2>
constexpr explicit duration(const Rep2& r);
template<class Rep2, class Period2>
constexpr duration(const duration<Rep2, Period2>& d);
~duration() = default;
duration(const duration&) = default;
duration& operator=(const duration&) = default;
// наблюдатель
constexpr rep count() const;
// арифметика
constexpr common_type_t<duration> operator+() const;
constexpr common_type_t<duration> operator-() const;
constexpr duration& operator++();
constexpr duration operator++(int);
constexpr duration& operator--();
constexpr duration operator--(int);
constexpr duration& operator+=(const duration& d);
constexpr duration& operator-=(const duration& d);
constexpr duration& operator*=(const rep& rhs);
constexpr duration& operator/=(const rep& rhs);
constexpr duration& operator%=(const rep& rhs);
constexpr duration& operator%=(const duration& rhs);
// специальные значения
static constexpr duration zero() noexcept;
static constexpr duration min() noexcept;
static constexpr duration max() noexcept;
};
}
Шаблонный класс std::chrono::time_point
namespace std::chrono {
template<class Clock, class Duration = typename Clock::duration>
class time_point {
public:
using clock = Clock;
using duration = Duration;
using rep = typename duration::rep;
using period = typename duration::period;
private:
duration d_; // только экспозиция
public:
// создание
constexpr time_point(); // имеет значение эпохи
constexpr explicit time_point(const duration& d); // то же, что time_point() + d
template<class Duration2>
constexpr time_point(const time_point<clock, Duration2>& t);
// наблюдатель
constexpr duration time_since_epoch() const;
// арифметика
constexpr time_point& operator++();
constexpr time_point operator++(int);
constexpr time_point& operator--();
constexpr time_point operator--(int);
constexpr time_point& operator+=(const duration& d);
constexpr time_point& operator-=(const duration& d);
// специальные значения
static constexpr time_point min() noexcept;
static constexpr time_point max() noexcept;
};
}
Специализация шаблона класса std::common_type для std::chrono::duration
namespace std {
template<class Rep1, class Period1, class Rep2, class Period2>
struct common_type<chrono::duration<Rep1, Period1>,
chrono::duration<Rep2, Period2>> {
using type = chrono::duration<common_type_t<Rep1, Rep2>, /* смотрите описание */>;
};
}
Специализация шаблона класса std::common_type для std::chrono::time_point
namespace std {
template<class Clock, class Duration1, class Duration2>
struct common_type<chrono::time_point<Clock, Duration1>,
chrono::time_point<Clock, Duration2>> {
using type = chrono::time_point<Clock, common_type_t<Duration1, Duration2>>;
};
}
Шаблонный класс std::chrono::treat_as_floating_point
template<class Rep> struct treat_as_floating_point : is_floating_point<Rep> { };
Шаблонный класс std::chrono::duration_values
namespace std::chrono {
template<class Rep>
struct duration_values {
public:
static constexpr Rep zero() noexcept;
static constexpr Rep min() noexcept;
static constexpr Rep max() noexcept;
};
}
Класс std::chrono::system_clock
namespace std::chrono {
class system_clock {
public:
using rep = /* смотрите описание */;
using period = ratio</* не указано */, /* не указано */>;
using duration = chrono::duration<rep, period>;
using time_point = chrono::time_point<system_clock>;
static constexpr bool is_steady = /* не указано */;
static time_point now() noexcept;
// отображение в/из типа C time_t
static time_t to_time_t (const time_point& t) noexcept;
static time_point from_time_t(time_t t) noexcept;
};
}
Класс std::chrono::utc_clock
namespace std::chrono {
class utc_clock {
public:
using rep = /* знаковый арифметический тип */;
using period = ratio</* не указано */, /* не указано */>;
using duration = chrono::duration<rep, period>;
using time_point = chrono::time_point<utc_clock>;
static constexpr bool is_steady = /* не указано */;
static time_point now();
template<class Duration>
static sys_time<common_type_t<Duration, seconds>>
to_sys(const utc_time<Duration>& t);
template<class Duration>
static utc_time<common_type_t<Duration, seconds>>
from_sys(const sys_time<Duration>& t);
};
}
Класс std::chrono::tai_clock
namespace std::chrono {
class tai_clock {
public:
using rep = /* знаковый арифметический тип */;
using period = ratio</* не указано */, /* не указано */>;
using duration = chrono::duration<rep, period>;
using time_point = chrono::time_point<tai_clock>;
static constexpr bool is_steady = /* не указано */;
static time_point now();
template<class Duration>
static sys_time<common_type_t<Duration, seconds>>
to_sys(const tai_time<Duration>& t);
template<class Duration>
static tai_time<common_type_t<Duration, seconds>>
from_sys(const sys_time<Duration>& t);
};
}
Класс std::chrono::gps_clock
namespace std::chrono {
class gps_clock {
public:
using rep = /* знаковый арифметический тип */;
using period = ratio</* не указано */, /* не указано */>;
using duration = chrono::duration<rep, period>;
using time_point = chrono::time_point<gps_clock>;
static constexpr bool is_steady = /* не указано */;
static time_point now();
template<class Duration>
static sys_time<common_type_t<Duration, seconds>>
to_sys(const gps_time<Duration>& t);
template<class Duration>
static gps_time<common_type_t<Duration, seconds>>
from_sys(const sys_time<Duration>& t);
};
}
Класс std::chrono::steady_clock
namespace std::chrono {
class steady_clock {
public:
using rep = /* не указано */;
using period = ratio</* не указано */, /* не указано */>;
using duration = chrono::duration<rep, period>;
using time_point = chrono::time_point</* не указано */, duration>;
static constexpr bool is_steady = true;
static time_point now() noexcept;
};
}
Класс std::chrono::high_resolution_clock
namespace std::chrono {
class high_resolution_clock {
public:
using rep = /* не указано */;
using period = ratio</* не указано */, /* не указано */>;
using duration = chrono::duration<rep, period>;
using time_point = chrono::time_point</* не указано */, duration>;
static constexpr bool is_steady = /* не указано */;
static time_point now() noexcept;
};
}
Шаблонный класс std::chrono::clock_time_conversion
namespace std::chrono {
template<class DestClock, class SourceClock>
struct clock_time_conversion {};
template<class Clock>
struct clock_time_conversion<Clock, Clock> {
template<class Duration>
time_point<Clock, Duration>
operator()(const time_point<Clock, Duration>& t) const;
};
template<>
struct clock_time_conversion<system_clock, system_clock> {
template<class Duration>
sys_time<Duration>
operator()(const sys_time<Duration>& t) const;
};
template<>
struct clock_time_conversion<utc_clock, utc_clock> {
template<class Duration>
utc_time<Duration>
operator()(const utc_time<Duration>& t) const;
};
template<>
struct clock_time_conversion<utc_clock, system_clock> {
template<class Duration>
utc_time<common_type_t<Duration, seconds>>
operator()(const sys_time<Duration>& t) const;
};
template<>
struct clock_time_conversion<system_clock, utc_clock> {
template<class Duration>
sys_time<common_type_t<Duration, seconds>>
operator()(const utc_time<Duration>& t) const;
};
template<class SourceClock>
struct clock_time_conversion<system_clock, SourceClock> {
template<class Duration>
auto operator()(const time_point<SourceClock, Duration>& t) const
-> decltype(SourceClock::to_sys(t));
};
template<class DestClock>
struct clock_time_conversion<DestClock, system_clock> {
template<class Duration>
auto operator()(const sys_time<Duration>& t) const
-> decltype(DestClock::from_sys(t));
};
template<class SourceClock>
struct clock_time_conversion<utc_clock, SourceClock> {
template<class Duration>
auto operator()(const time_point<SourceClock, Duration>& t) const
-> decltype(SourceClock::to_utc(t));
};
template<class DestClock>
struct clock_time_conversion<DestClock, utc_clock> {
template<class Duration>
auto operator()(const utc_time<Duration>& t) const
-> decltype(DestClock::from_utc(t));
};
}
Класс std::chrono::last_spec
namespace std::chrono {
struct last_spec {
explicit last_spec() = default;
};
}
Класс std::chrono::day
namespace std::chrono {
class day {
unsigned char d_; // только экспозиция
public:
day() = default;
constexpr explicit day(unsigned d) noexcept;
constexpr day& operator++() noexcept;
constexpr day operator++(int) noexcept;
constexpr day& operator--() noexcept;
constexpr day operator--(int) noexcept;
constexpr day& operator+=(const days& d) noexcept;
constexpr day& operator-=(const days& d) noexcept;
constexpr explicit operator unsigned() const noexcept;
constexpr bool ok() const noexcept;
};
}
Класс std::chrono::month
namespace std::chrono {
class month {
unsigned char m_; // только экспозиция
public:
month() = default;
constexpr explicit month(unsigned m) noexcept;
constexpr month& operator++() noexcept;
constexpr month operator++(int) noexcept;
constexpr month& operator--() noexcept;
constexpr month operator--(int) noexcept;
constexpr month& operator+=(const months& m) noexcept;
constexpr month& operator-=(const months& m) noexcept;
constexpr explicit operator unsigned() const noexcept;
constexpr bool ok() const noexcept;
};
}
Класс std::chrono::year
namespace std::chrono {
class year {
short y_; // только экспозиция
public:
year() = default;
constexpr explicit year(int y) noexcept;
constexpr year& operator++() noexcept;
constexpr year operator++(int) noexcept;
constexpr year& operator--() noexcept;
constexpr year operator--(int) noexcept;
constexpr year& operator+=(const years& y) noexcept;
constexpr year& operator-=(const years& y) noexcept;
constexpr year operator+() const noexcept;
constexpr year operator-() const noexcept;
constexpr bool is_leap() const noexcept;
constexpr explicit operator int() const noexcept;
constexpr bool ok() const noexcept;
static constexpr year min() noexcept;
static constexpr year max() noexcept;
};
}
Класс std::chrono::weekday
namespace std::chrono {
class weekday {
unsigned char wd_; // только экспозиция
public:
weekday() = default;
constexpr explicit weekday(unsigned wd) noexcept;
constexpr weekday(const sys_days& dp) noexcept;
constexpr explicit weekday(const local_days& dp) noexcept;
constexpr weekday& operator++() noexcept;
constexpr weekday operator++(int) noexcept;
constexpr weekday& operator--() noexcept;
constexpr weekday operator--(int) noexcept;
constexpr weekday& operator+=(const days& d) noexcept;
constexpr weekday& operator-=(const days& d) noexcept;
constexpr unsigned c_encoding() const noexcept;
constexpr unsigned iso_encoding() const noexcept;
constexpr bool ok() const noexcept;
constexpr weekday_indexed operator[](unsigned index) const noexcept;
constexpr weekday_last operator[](last_spec) const noexcept;
};
}
Класс std::chrono::weekday_indexed
namespace std::chrono {
class weekday_indexed {
chrono::weekday wd_; // только экспозиция
unsigned char index_; // только экспозиция
public:
weekday_indexed() = default;
constexpr weekday_indexed(const chrono::weekday& wd, unsigned index) noexcept;
constexpr chrono::weekday weekday() const noexcept;
constexpr unsigned index() const noexcept;
constexpr bool ok() const noexcept;
};
}
Класс std::chrono::weekday_last
namespace std::chrono {
class weekday_last {
chrono::weekday wd_; // только экспозиция
public:
constexpr explicit weekday_last(const chrono::weekday& wd) noexcept;
constexpr chrono::weekday weekday() const noexcept;
constexpr bool ok() const noexcept;
};
}
Класс std::chrono::month_day
namespace std::chrono {
class month_day {
chrono::month m_; // только экспозиция
chrono::day d_; // только экспозиция
public:
month_day() = default;
constexpr month_day(const chrono::month& m, const chrono::day& d) noexcept;
constexpr chrono::month month() const noexcept;
constexpr chrono::day day() const noexcept;
constexpr bool ok() const noexcept;
};
}
Класс std::chrono::month_day_last
namespace std::chrono {
class month_day_last {
chrono::month m_; // только экспозиция
public:
constexpr explicit month_day_last(const chrono::month& m) noexcept;
constexpr chrono::month month() const noexcept;
constexpr bool ok() const noexcept;
};
}
Класс std::chrono::month_weekday
namespace std::chrono {
class month_weekday {
chrono::month m_; // только экспозиция
chrono::weekday_indexed wdi_; // только экспозиция
public:
constexpr month_weekday(const chrono::month& m,
const chrono::weekday_indexed& wdi) noexcept;
constexpr chrono::month month() const noexcept;
constexpr chrono::weekday_indexed weekday_indexed() const noexcept;
constexpr bool ok() const noexcept;
};
}
Класс std::chrono::month_weekday_last
namespace std::chrono {
class month_weekday_last {
chrono::month m_; // только экспозиция
chrono::weekday_last wdl_; // только экспозиция
public:
constexpr month_weekday_last(const chrono::month& m,
const chrono::weekday_last& wdl) noexcept;
constexpr chrono::month month() const noexcept;
constexpr chrono::weekday_last weekday_last() const noexcept;
constexpr bool ok() const noexcept;
};
}
Класс std::chrono::year_month
namespace std::chrono {
class year_month {
chrono::year y_; // только экспозиция
chrono::month m_; // только экспозиция
public:
year_month() = default;
constexpr year_month(const chrono::year& y, const chrono::month& m) noexcept;
constexpr chrono::year year() const noexcept;
constexpr chrono::month month() const noexcept;
constexpr year_month& operator+=(const months& dm) noexcept;
constexpr year_month& operator-=(const months& dm) noexcept;
constexpr year_month& operator+=(const years& dy) noexcept;
constexpr year_month& operator-=(const years& dy) noexcept;
constexpr bool ok() const noexcept;
};
}
Класс std::chrono::year_month_day
namespace std::chrono {
class year_month_day {
chrono::year y_; // только экспозиция
chrono::month m_; // только экспозиция
chrono::day d_; // только экспозиция
public:
year_month_day() = default;
constexpr year_month_day(const chrono::year& y, const chrono::month& m,
const chrono::day& d) noexcept;
constexpr year_month_day(const year_month_day_last& ymdl) noexcept;
constexpr year_month_day(const sys_days& dp) noexcept;
constexpr explicit year_month_day(const local_days& dp) noexcept;
constexpr year_month_day& operator+=(const months& m) noexcept;
constexpr year_month_day& operator-=(const months& m) noexcept;
constexpr year_month_day& operator+=(const years& y) noexcept;
constexpr year_month_day& operator-=(const years& y) noexcept;
constexpr chrono::year year() const noexcept;
constexpr chrono::month month() const noexcept;
constexpr chrono::day day() const noexcept;
constexpr operator sys_days() const noexcept;
constexpr explicit operator local_days() const noexcept;
constexpr bool ok() const noexcept;
};
}
Класс std::chrono::year_month_day_last
namespace std::chrono {
class year_month_day_last {
chrono::year y_; // только экспозиция
chrono::month_day_last mdl_; // только экспозиция
public:
constexpr year_month_day_last(const chrono::year& y,
const chrono::month_day_last& mdl) noexcept;
constexpr year_month_day_last& operator+=(const months& m) noexcept;
constexpr year_month_day_last& operator-=(const months& m) noexcept;
constexpr year_month_day_last& operator+=(const years& y) noexcept;
constexpr year_month_day_last& operator-=(const years& y) noexcept;
constexpr chrono::year year() const noexcept;
constexpr chrono::month month() const noexcept;
constexpr chrono::month_day_last month_day_last() const noexcept;
constexpr chrono::day day() const noexcept;
constexpr operator sys_days() const noexcept;
constexpr explicit operator local_days() const noexcept;
constexpr bool ok() const noexcept;
};
}
Класс std::chrono::year_month_weekday
namespace std::chrono {
class year_month_weekday {
chrono::year y_; // только экспозиция
chrono::month m_; // только экспозиция
chrono::weekday_indexed wdi_; // только экспозиция
public:
year_month_weekday() = default;
constexpr year_month_weekday(const chrono::year& y, const chrono::month& m,
const chrono::weekday_indexed& wdi) noexcept;
constexpr year_month_weekday(const sys_days& dp) noexcept;
constexpr explicit year_month_weekday(const local_days& dp) noexcept;
constexpr year_month_weekday& operator+=(const months& m) noexcept;
constexpr year_month_weekday& operator-=(const months& m) noexcept;
constexpr year_month_weekday& operator+=(const years& y) noexcept;
constexpr year_month_weekday& operator-=(const years& y) noexcept;
constexpr chrono::year year() const noexcept;
constexpr chrono::month month() const noexcept;
constexpr chrono::weekday weekday() const noexcept;
constexpr unsigned index() const noexcept;
constexpr chrono::weekday_indexed weekday_indexed() const noexcept;
constexpr operator sys_days() const noexcept;
constexpr explicit operator local_days() const noexcept;
constexpr bool ok() const noexcept;
};
}
Класс std::chrono::year_month_weekday_last
namespace std::chrono {
class year_month_weekday_last {
chrono::year y_; // только экспозиция
chrono::month m_; // только экспозиция
chrono::weekday_last wdl_; // только экспозиция
public:
constexpr year_month_weekday_last(const chrono::year& y, const chrono::month& m,
const chrono::weekday_last& wdl) noexcept;
constexpr year_month_weekday_last& operator+=(const months& m) noexcept;
constexpr year_month_weekday_last& operator-=(const months& m) noexcept;
constexpr year_month_weekday_last& operator+=(const years& y) noexcept;
constexpr year_month_weekday_last& operator-=(const years& y) noexcept;
constexpr chrono::year year() const noexcept;
constexpr chrono::month month() const noexcept;
constexpr chrono::weekday weekday() const noexcept;
constexpr chrono::weekday_last weekday_last() const noexcept;
constexpr operator sys_days() const noexcept;
constexpr explicit operator local_days() const noexcept;
constexpr bool ok() const noexcept;
};
}
Шаблонный класс std::chrono::hh_mm_ss
namespace std::chrono {
template<class Duration> class hh_mm_ss {
public:
static constexpr unsigned fractional_width = /* смотрите описание */;
using precision = /* смотрите описание */;
constexpr hh_mm_ss() noexcept : hh_mm_ss{Duration::zero()} {}
constexpr explicit hh_mm_ss(Duration d);
constexpr bool is_negative() const noexcept;
constexpr chrono::hours hours() const noexcept;
constexpr chrono::minutes minutes() const noexcept;
constexpr chrono::seconds seconds() const noexcept;
constexpr precision subseconds() const noexcept;
constexpr explicit operator precision() const noexcept;
constexpr precision to_duration() const noexcept;
private:
bool is_neg; // только экспозиция
chrono::hours h; // только экспозиция
chrono::minutes m; // только экспозиция
chrono::seconds s; // только экспозиция
precision ss; // только экспозиция
};
}
Класс std::chrono::tzdb
namespace std::chrono {
struct tzdb {
string version;
vector<time_zone> zones;
vector<time_zone_link> links;
vector<leap_second> leap_seconds;
const time_zone* locate_zone(string_view tz_name) const;
const time_zone* current_zone() const;
};
}
Класс std::chrono::tzdb_list
namespace std::chrono {
class tzdb_list {
public:
tzdb_list(const tzdb_list&) = delete;
tzdb_list& operator=(const tzdb_list&) = delete;
// неуказанные дополнительные конструкторы
class const_iterator;
const tzdb& front() const noexcept;
const_iterator erase_after(const_iterator p);
const_iterator begin() const noexcept;
const_iterator end() const noexcept;
const_iterator cbegin() const noexcept;
const_iterator cend() const noexcept;
};
}
Класс std::chrono::nonexistent_local_time
namespace std::chrono {
class nonexistent_local_time : public runtime_error {
public:
template<class Duration>
nonexistent_local_time(const local_time<Duration>& tp, const local_info& i);
};
}
Класс std::chrono::ambiguous_local_time
namespace std::chrono {
class ambiguous_local_time : public runtime_error {
public:
template<class Duration>
ambiguous_local_time(const local_time<Duration>& tp, const local_info& i);
};
}
Класс std::chrono::sys_info
namespace std::chrono {
struct sys_info {
sys_seconds begin;
sys_seconds end;
seconds offset;
minutes save;
string abbrev;
};
}
Класс std::chrono::local_info
namespace std::chrono {
struct local_info {
static constexpr int unique = 0;
static constexpr int nonexistent = 1;
static constexpr int ambiguous = 2;
int result;
sys_info first;
sys_info second;
};
}
Класс std::chrono::time_zone
namespace std::chrono {
class time_zone {
public:
time_zone(time_zone&&) = default;
time_zone& operator=(time_zone&&) = default;
// неуказанные дополнительные конструкторы
string_view name() const noexcept;
template<class Duration> sys_info get_info(const sys_time<Duration>& st) const;
template<class Duration> local_info get_info(const local_time<Duration>& tp) const;
template<class Duration>
sys_time<common_type_t<Duration, seconds>>
to_sys(const local_time<Duration>& tp) const;
template<class Duration>
sys_time<common_type_t<Duration, seconds>>
to_sys(const local_time<Duration>& tp, choose z) const;
template<class Duration>
local_time<common_type_t<Duration, seconds>>
to_local(const sys_time<Duration>& tp) const;
};
}
Шаблонный класс std::chrono::zoned_traits
namespace std::chrono {
template<class T> struct zoned_traits {};
template<> struct zoned_traits<const time_zone*> {
static const time_zone* default_zone();
static const time_zone* locate_zone(string_view name);
};
}
Шаблонный класс std::chrono::zoned_time
namespace std::chrono {
template<class Duration, class TimeZonePtr = const time_zone*>
class zoned_time {
public:
using duration = common_type_t<Duration, seconds>;
private:
TimeZonePtr zone_; // только экспозиция
sys_time<duration> tp_; // только экспозиция
using traits = zoned_traits<TimeZonePtr>; // только экспозиция
public:
zoned_time();
zoned_time(const zoned_time&) = default;
zoned_time& operator=(const zoned_time&) = default;
zoned_time(const sys_time<Duration>& st);
explicit zoned_time(TimeZonePtr z);
explicit zoned_time(string_view name);
template<class Duration2>
zoned_time(const zoned_time<Duration2, TimeZonePtr>& zt);
zoned_time(TimeZonePtr z, const sys_time<Duration>& st);
zoned_time(string_view name, const sys_time<Duration>& st);
zoned_time(TimeZonePtr z, const local_time<Duration>& tp);
zoned_time(string_view name, const local_time<Duration>& tp);
zoned_time(TimeZonePtr z, const local_time<Duration>& tp, choose c);
zoned_time(string_view name, const local_time<Duration>& tp, choose c);
template<class Duration2, class TimeZonePtr2>
zoned_time(TimeZonePtr z, const zoned_time<Duration2, TimeZonePtr2>& zt);
template<class Duration2, class TimeZonePtr2>
zoned_time(TimeZonePtr z, const zoned_time<Duration2, TimeZonePtr2>& zt, choose);
template<class Duration2, class TimeZonePtr2>
zoned_time(string_view name, const zoned_time<Duration2, TimeZonePtr2>& zt);
template<class Duration2, class TimeZonePtr2>
zoned_time(string_view name, const zoned_time<Duration2, TimeZonePtr2>& zt, choose);
zoned_time& operator=(const sys_time<Duration>& st);
zoned_time& operator=(const local_time<Duration>& ut);
operator sys_time<duration>() const;
explicit operator local_time<duration>() const;
TimeZonePtr get_time_zone() const;
local_time<duration> get_local_time() const;
sys_time<duration> get_sys_time() const;
sys_info get_info() const;
};
zoned_time() -> zoned_time<seconds>;
template<class Duration>
zoned_time(sys_time<Duration>)
-> zoned_time<common_type_t<Duration, seconds>>;
template<class TimeZonePtrOrName>
using /*представление часового пояса*/ = // только экспозиция
conditional_t<is_convertible_v<TimeZonePtrOrName, string_view>,
const time_zone*,
remove_cvref_t<TimeZonePtrOrName>>;
template<class TimeZonePtrOrName>
zoned_time(TimeZonePtrOrName&&)
-> zoned_time<seconds, /*представление часового пояса*/<TimeZonePtrOrName>>;
template<class TimeZonePtrOrName, class Duration>
zoned_time(TimeZonePtrOrName&&, sys_time<Duration>)
-> zoned_time<common_type_t<Duration, seconds>,
/*представление часового пояса*/<TimeZonePtrOrName>>;
template<class TimeZonePtrOrName, class Duration>
zoned_time(TimeZonePtrOrName&&, local_time<Duration>,
choose = choose::earliest)
-> zoned_time<common_type_t<Duration, seconds>,
/*представление часового пояса*/<TimeZonePtrOrName>>;
template<class Duration, class TimeZonePtrOrName, class TimeZonePtr2>
zoned_time(TimeZonePtrOrName&&, zoned_time<Duration, TimeZonePtr2>,
choose = choose::earliest)
-> zoned_time<common_type_t<Duration, seconds>,
/*представление часового пояса*/<TimeZonePtrOrName>>;
}
Класс std::chrono::leap_second
namespace std::chrono {
class leap_second {
public:
leap_second(const leap_second&) = default;
leap_second& operator=(const leap_second&) = default;
// неуказанные дополнительные конструкторы
constexpr sys_seconds date() const noexcept;
constexpr seconds value() const noexcept;
};
}
Класс std::chrono::time_zone_link
namespace std::chrono {
class time_zone_link {
public:
time_zone_link(time_zone_link&&) = default;
time_zone_link& operator=(time_zone_link&&) = default;
// неуказанные дополнительные конструкторы
string_view name() const noexcept;
string_view target() const noexcept;
};
}
Шаблонный класс local-time-format-t
namespace std::chrono {
template<class Duration> struct /*local-time-format-t*/ { // только для пояснения
local_time<Duration> time; // только для пояснения
const string* abbrev; // только для пояснения
const seconds* offset_sec; // только для пояснения
};
}
