⚙️ C++

Работа с датой и временем в C++: подробное руководство

Урок 31 / 39 • Полная теория для чтения

Что это такое и зачем? (аналогия из реальной жизни)

Представьте, что вы ведёте дневник. Вы записываете туда не только события, но и когда именно они произошли: «Сегодня, 15 марта 2025 года, в 14:30 я закончил читать книгу». Без даты и времени ваши записи превратились бы в бессмысленный список — вы бы не знали, что было раньше, а что позже, сколько времени прошло между событиями и когда наступит следующее важное дело.

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

Будильник на телефоне — нужно знать текущее время и сравнить его с заданным.
Календарь напоминаний — хранит даты событий и умеет показывать, что будет завтра.
Банковская система — фиксирует точное время каждого перевода.
Игра — считает, сколько времени игрок провёл в сессии.

💡 Главная идея: Дата и время — это не просто числа на экране. Это способ измерять, сравнивать и хранить моменты нашей жизни. Компьютер делает это с помощью специальных инструментов, которые мы сегодня изучим.

В C++ работа с датой и временем — это как работа с очень точными часами, которые умеют не только показывать текущее время, но и вычислять разницу между двумя моментами, прибавлять дни или часы, форматировать дату в удобный для человека вид и многое другое.

Теория: как это работает изнутри

Прежде чем писать код, давайте разберёмся, как компьютер вообще представляет время. Это поможет избежать множества ошибок в будущем.

Эпоха Unix (Unix Timestamp)

Большинство языков программирования, включая C++, используют эпоху Unix — это количество секунд, прошедших с 1 января 1970 года 00:00:00 по UTC (всемирное координированное время). Почему именно 1970 год? Потому что тогда была создана операционная система Unix, и разработчики договорились считать время именно от этой точки.

Например, число 1 704 000 000 — это количество секунд, прошедших с 1 января 1970 года до какого-то момента в 2024 году. Компьютеру так удобно: одно число, с которым легко выполнять математические операции — сложить, вычесть, сравнить.

⚠️ Важно: Для человека число 1 704 000 000 ничего не значит. Но компьютер может легко преобразовать его в «15 декабря 2024 года, 14:20:00». Именно для этого существуют функции форматирования.

Типы данных для времени в C++

В современном C++ (начиная со стандарта C++11 и особенно C++20) есть несколько способов работать со временем. Мы рассмотрим два основных подхода:

Подход	Библиотека	Когда использовать
Классический (C-style)	`<ctime>`	Для простых задач: получить текущее время, вывести дату, измерить разницу в секундах.
Современный (C++11/20)	`<chrono>`	Для сложных задач: работа с разными единицами (миллисекунды, микросекунды), точные замеры, календарные даты.

В этой статье мы сосредоточимся на современном подходе с использованием библиотеки <chrono>, так как он безопаснее, удобнее и является стандартом в индустрии. Но и классический способ тоже рассмотрим — он всё ещё используется в старых проектах.

Основные компоненты chrono

Библиотека <chrono> состоит из трёх главных частей:

Часы (Clock) — источник времени. Бывают разные: system_clock (системное время, которое мы видим на часах), steady_clock (монотонные часы, которые никогда не идут назад — идеально для замеров), high_resolution_clock (самые точные часы, которые есть на компьютере).
Момент времени (Time Point) — конкретная точка на временной оси. Например, «сейчас» или «1 января 2025 года ровно в полдень».
Длительность (Duration) — промежуток времени. Например, «5 секунд», «2 часа», «100 миллисекунд».

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

Синтаксис в C++: все формы и варианты

Давайте разберём основные операции с датой и временем. Мы будем использовать как классический подход (<ctime>), так и современный (<chrono>).

1. Получение текущего времени (классический способ)

#include <iostream>
#include <ctime>  // подключаем библиотеку для работы со временем

int main() {
    // Получаем текущее время в виде количества секунд с 1970 года
    std::time_t current_time = std::time(nullptr);
    
    // Преобразуем в понятный для человека формат
    char* readable_time = std::ctime(&current_time);
    
    std::cout << "Текущее время: " << readable_time;
    
    return 0;
}

Объяснение:

std::time_t — это тип данных, который хранит количество секунд. Обычно это просто целое число (long).
std::time(nullptr) — функция, которая возвращает текущее время. Если передать nullptr, она просто вернёт число.
std::ctime() — преобразует число в строку вида "Tue Dec 15 14:20:00 2024".

2. Получение текущего времени (современный способ с chrono)

#include <iostream>
#include <chrono>  // современная библиотека для работы со временем
#include <ctime>   // всё ещё нужна для преобразования в читаемый формат

int main() {
    // Получаем текущий момент времени с помощью системных часов
    auto now = std::chrono::system_clock::now();
    
    // Преобразуем в time_t для вывода на экран
    std::time_t now_time_t = std::chrono::system_clock::to_time_t(now);
    
    std::cout << "Текущее время: " << std::ctime(&now_time_t);
    
    return 0;
}

Объяснение:

std::chrono::system_clock::now() — возвращает текущий момент времени. Тип этого значения — std::chrono::time_point.
std::chrono::system_clock::to_time_t() — преобразует современный time_point в старый добрый time_t, чтобы мы могли вывести его на экран.

3. Работа с длительностями (Duration)

#include <iostream>
#include <chrono>
#include <thread>  // для функции sleep

int main() {
    // Создаём длительность в 5 секунд
    std::chrono::seconds five_seconds(5);
    
    // Можно создать в миллисекундах
    std::chrono::milliseconds hundred_ms(100);
    
    // Можно складывать разные длительности
    auto total = five_seconds + hundred_ms;
    
    std::cout << "Всего: " << total.count() << " миллисекунд" << std::endl;
    // Выведет: Всего: 5100 миллисекунд
    
    // Используем для паузы в программе
    std::cout << "Ждём 2 секунды..." << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::cout << "Готово!" << std::endl;
    
    return 0;
}

Объяснение:

std::chrono::seconds, milliseconds, microseconds, nanoseconds — это типы для разных единиц измерения.
.count() — возвращает количество единиц (например, сколько секунд или миллисекунд).
std::this_thread::sleep_for() — усыпляет программу на заданное время.

4. Измерение времени выполнения кода

#include <iostream>
#include <chrono>

int main() {
    // Запоминаем время начала
    auto start = std::chrono::steady_clock::now();
    
    // Какой-то код, который мы хотим измерить
    long long sum = 0;
    for (int i = 0; i < 1000000; ++i) {
        sum += i;
    }
    
    // Запоминаем время окончания
    auto end = std::chrono::steady_clock::now();
    
    // Вычисляем разницу
    auto duration = end - start;
    
    // Преобразуем в нужные единицы
    auto milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(duration);
    auto microseconds = std::chrono::duration_cast<std::chrono::microseconds>(duration);
    
    std::cout << "Результат: " << sum << std::endl;
    std::cout << "Время выполнения: " << milliseconds.count() << " мс" << std::endl;
    std::cout << "Время выполнения: " << microseconds.count() << " мкс" << std::endl;
    
    return 0;
}

Объяснение:

steady_clock — идеален для замеров, так как он монотонный (не зависит от перевода часов).
duration_cast — преобразует длительность из одних единиц в другие. Например, из наносекунд в миллисекунды.

5. Форматирование даты (C++20)

#include <iostream>
#include <chrono>
#include <format>  // C++20, для форматирования

int main() {
    auto now = std::chrono::system_clock::now();
    
    // Преобразуем в time_point с точностью до дня
    auto today = std::chrono::floor<std::chrono::days>(now);
    
    // Преобразуем в структуру year_month_day
    std::chrono::year_month_day ymd(today);
    
    std::cout << "Год: " << (int)ymd.year() << std::endl;
    std::cout << "Месяц: " << (unsigned)ymd.month() << std::endl;
    std::cout << "День: " << (unsigned)ymd.day() << std::endl;
    
    // Форматирование с помощью std::format (C++20)
    std::cout << std::format("Сегодня: {:%d.%m.%Y}", now) << std::endl;
    
    return 0;
}

Объяснение:

std::chrono::floor<std::chrono::days> — округляет время вниз до начала дня (полночь).
std::chrono::year_month_day — структура, которая хранит год, месяц и день отдельно.
std::format — мощный инструмент форматирования, похожий на Python f-строки.

Примеры кода — от простого к сложному

Пример 1: Простой таймер обратного отсчёта

#include <iostream>
#include <chrono>
#include <thread>

int main() {
    int seconds = 5;
    std::cout << "Обратный отсчёт начался!" << std::endl;
    
    for (int i = seconds; i > 0; --i) {
        std::cout << i << "..." << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
    
    std::cout << "Время вышло!" << std::endl;
    return 0;
}

Что здесь происходит: Программа каждую секунду выводит число, уменьшая его от 5 до 1. Функция sleep_for приостанавливает выполнение ровно на 1 секунду.

Пример 2: Вычисление возраста

#include <iostream>
#include <chrono>

int main() {
    // Дата рождения: 15 марта 2000 года
    std::chrono::year_month_day birthday{std::chrono::year(2000), 
                                          std::chrono::month(3), 
                                          std::chrono::day(15)};
    
    // Текущая дата
    auto now = std::chrono::system_clock::now();
    auto today = std::chrono::floor<std::chrono::days>(now);
    std::chrono::year_month_day today_ymd(today);
    
    // Вычисляем возраст
    int age = (int)today_ymd.year() - (int)birthday.year();
    
    // Проверяем, был ли уже день рождения в этом году
    if (today_ymd.month() < birthday.month() || 
        (today_ymd.month() == birthday.month() && today_ymd.day() < birthday.day())) {
        age--;
    }
    
    std::cout << "Возраст: " << age << " лет" << std::endl;
    
    return 0;
}

Объяснение: Мы создаём дату рождения, получаем текущую дату и вычисляем разницу в годах. Затем проверяем, был ли уже день рождения в этом году — если нет, вычитаем один год.

Пример 3: Сколько дней до Нового года?

#include <iostream>
#include <chrono>

int main() {
    auto now = std::chrono::system_clock::now();
    auto today = std::chrono::floor<std::chrono::days>(now);
    std::chrono::year_month_day today_ymd(today);
    
    // Создаём дату следующего Нового года
    auto next_year = std::chrono::year((int)today_ymd.year() + 1);
    std::chrono::year_month_day new_year{next_year, 
                                          std::chrono::month(1), 
                                          std::chrono::day(1)};
    
    // Преобразуем обе даты в time_point для вычисления разницы
    auto new_year_time = std::chrono::sys_days(new_year);
    auto today_time = std::chrono::sys_days(today_ymd);
    
    // Разница в днях
    auto days_until = (new_year_time - today_time).count();
    
    std::cout << "До Нового года осталось " << days_until << " дней!" << std::endl;
    
    return 0;
}

Объяснение: sys_days — это time_point, который представляет дни. Вычитая один из другого, мы получаем разницу в днях.

Пример 4: Парсинг даты из строки

#include <iostream>
#include <chrono>
#include <sstream>
#include <iomanip>

int main() {
    std::string date_str = "2024-12-25 10:30:00";
    std::tm tm = {};
    std::istringstream ss(date_str);
    
    // Парсим строку в структуру tm
    ss >> std::get_time(&tm, "%Y-%m-%d %H:%M:%S");
    
    if (ss.fail()) {
        std::cout << "Ошибка парсинга даты!" << std::endl;
        return 1;
    }
    
    // Преобразуем tm в time_t, затем в time_point
    std::time_t time = std::mktime(&tm);
    auto tp = std::chrono::system_clock::from_time_t(time);
    
    std::cout << "Успешно распарсили дату!" << std::endl;
    
    return 0;
}

Объяснение: std::get_time — функция, которая читает дату из строки по заданному формату. %Y — год, %m — месяц, %d — день, %H — часы, %M — минуты, %S — секунды.

Пример 5: Измерение скорости работы алгоритма

#include <iostream>
#include <chrono>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> data(100000);
    
    // Заполняем вектор случайными числами
    for (int i = 0; i < 100000; ++i) {
        data[i] = rand() % 100000;
    }
    
    // Измеряем время сортировки
    auto start = std::chrono::high_resolution_clock::now();
    
    std::sort(data.begin(), data.end());
    
    auto end = std::chrono::high_resolution_clock::now();
    
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
    
    std::cout << "Сортировка 100000 элементов заняла: " 
              << duration.count() << " мс" << std::endl;
    
    return 0;
}

Объяснение: Мы используем high_resolution_clock — самые точные часы. Замеряем время до и после сортировки, затем выводим разницу в миллисекундах.

Пример 6: Календарь на месяц

#include <iostream>
#include <chrono>

int main() {
    int year = 2025;
    int month = 3;  // Март
    
    std::chrono::year_month_day first_day{std::chrono::year(year), 
                                           std::chrono::month(month), 
                                           std::chrono::day(1)};
    
    // Получаем количество дней в месяце
    auto last_day = std::chrono::year_month_day_last(
        std::chrono::year(year), 
        std::chrono::month_day_last(std::chrono::month(month))
    );
    
    unsigned days_in_month = (unsigned)last_day.day();
    
    std::cout << "Календарь на " << month << "/" << year << std::endl;
    std::cout << "Пн Вт Ср Чт Пт Сб Вс" << std::endl;
    
    // Выводим дни
    for (unsigned day = 1; day <= days_in_month; ++day) {
        std::cout << std::setw(2) << day << " ";
        // После воскресенья переходим на новую строку
        // (упрощённо — каждые 7 дней)
        if (day % 7 == 0) {
            std::cout << std::endl;
        }
    }
    std::cout << std::endl;
    
    return 0;
}

Объяснение: year_month_day_last — специальный тип, который представляет последний день месяца. Мы используем его, чтобы узнать, сколько дней в марте 2025 года.

Пример 7: Таймер с точностью до миллисекунд

#include <iostream>
#include <chrono>
#include <thread>

int main() {
    std::cout << "Нажмите Enter, чтобы запустить таймер..." << std::endl;
    std::cin.get();
    
    auto start = std::chrono::steady_clock::now();
    
    std::cout << "Нажмите Enter, чтобы остановить таймер..." << std::endl;
    std::cin.get();
    
    auto end = std::chrono::steady_clock::now();
    
    auto duration = end - start;
    
    auto hours = std::chrono::duration_cast<std::chrono::hours>(duration);
    auto minutes = std::chrono::duration_cast<std::chrono::minutes>(duration - hours);
    auto seconds = std::chrono::duration_cast<std::chrono::seconds>(duration - hours - minutes);
    auto milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(
        duration - hours - minutes - seconds
    );
    
    std::cout << "Прошло: " 
              << hours.count() << " часов "
              << minutes.count() << " минут "
              << seconds.count() << " секунд "
              << milliseconds.count() << " миллисекунд" << std::endl;
    
    return 0;
}

Объяснение: Мы создаём простой секундомер. Пользователь нажимает Enter для старта и ещё раз для остановки. Программа вычисляет разницу и разбивает её на часы, минуты, секунды и миллисекунды.

Сравнение с Python: чем похоже и чем отличается

Python — ещё один популярный язык, который часто используют для работы с датами. Давайте сравним подходы:

Операция	C++ (chrono)	Python (datetime)
Получить текущее время	`auto now = system_clock::now();`	`now = datetime.now()`
Создать конкретную дату	`year_month_day{year(2025), month(3), day(15)}`	`date(2025, 3, 15)`
Разница между датами	`auto diff = date1 - date2;`	`diff = date1 - date2`
Форматирование	`std::format("{:%d.%m.%Y}", now)`	`now.strftime("%d.%m.%Y")`
Парсинг из строки	`std::get_time(&tm, "%Y-%m-%d")`	`datetime.strptime("2025-03-15", "%Y-%m-%d")`
Измерение времени	`steady_clock::now()`	`time.perf_counter()`

Основные отличия:

Сложность: В C++ нужно явно указывать типы и использовать разные часы для разных задач. В Python всё проще — один объект datetime делает почти всё.
Производительность: C++ быстрее, особенно при большом количестве операций с датами.
Безопасность: C++ с chrono более типобезопасен — вы не сможете случайно сложить секунды с метрами. В Python такие ошибки возможны.
Удобство: Python выигрывает в простоте написания кода. C++ требует больше кода для тех же операций.

💡 Совет: Если вы пишете небольшую программу или скрипт — Python будет удобнее. Если вы создаёте высоконагруженную систему или игру — C++ даст больше контроля и производительности.

Типичные ошибки и подводные камни

Ошибка 1: Игнорирование часовых поясов

Самая распространённая ошибка новичков — думать, что время везде одинаковое. system_clock::now() возвращает время в UTC (всемирное время). Если вы живёте в Москве (UTC+3), то нужно прибавить 3 часа.

⚠️ Запомните: Всегда храните время в UTC, а преобразуйте в локальное только при выводе пользователю.

Ошибка 2: Использование time() для измерения производительности

Функция time() имеет точность только до секунды. Для измерения быстрых операций (меньше секунды) она бесполезна — всегда будет показывать 0.

Правильно: Используйте steady_clock или high_resolution_clock из chrono.

Ошибка 3: Забывание про високосные годы

При ручном вычислении дат легко ошибиться с 29 февраля. Всегда используйте библиотечные функции — они уже учитывают високосные годы.

Ошибка 4: Переполнение time_t

На 32-битных системах time_t может переполниться в 2038 году (проблема 2038 года). Используйте 64-битные системы или chrono, который не имеет этой проблемы.

Ошибка 5: Сравнение time_point из разных часов

Нельзя сравнивать time_point из system_clock и steady_clock — у них разные эпохи. Всегда используйте одни и те же часы для сравнения.

Лучшие практики и советы профессионалов

Всегда используйте chrono вместо ctime. Современный C++ предоставляет более безопасные и удобные инструменты. Старый C-style код оставьте для совместимости с легаси.
Храните время в UTC. Преобразуйте в локальное время только при отображении пользователю. Это избавит от головной боли с часовыми поясами.
Используйте duration_cast для преобразования единиц. Никогда не делите count() на 1000 вручную — это приводит к ошибкам округления.
Для замеров производительности используйте steady_clock. Он монотонный и не зависит от перевода часов или синхронизации с интернетом.
Избегайте ручного форматирования дат. Используйте std::format (C++20) или std::put_time. Это уменьшит количество ошибок.
Проверяйте результаты парсинга. Всегда проверяйте, успешно ли распарсилась дата из строки. Пользователь может ввести "32.13.2025".
Документируйте формат дат. Если ваша программа принимает даты от пользователя, чётко указывайте ожидаемый формат (например, "ДД.ММ.ГГГГ").

Вопросы для самопроверки

Вопрос: Что такое эпоха Unix и почему она начинается с 1970 года?

Ответ: Это количество секунд, прошедших с 1 января 1970 года. Выбрана эта дата, потому что тогда была создана операционная система Unix, и разработчики договорились считать время от этой точки.
Вопрос: Какая библиотека в C++ является современным стандартом для работы с датой и временем?

Ответ: <chrono>. Она появилась в C++11 и была значительно расширена в C++20.
Вопрос: В чём разница между system_clock и steady_clock?

Ответ: system_clock показывает реальное календарное время (может быть переведено назад или вперёд). steady_clock монотонный — он всегда идёт только вперёд, идеален для замер

← Предыдущая Модули, пакеты и импорт в C++: подробное руководст Вперёд → Регулярные выражения в C++: подробное руководство