C++ 高精度时间库 chrono 详解

日历基础与复合单位

C++20 引入了丰富的日历类型，支持格里高利历的基本元素及组合。

• 基础类型：day, month, year, weekday, last_spec
• 复合类型：year_month_day, year_month_weekday, month_day 等
• 时刻与时区：hh_mm_ss, time_zone, zoned_time

模板类

std::chrono::duration

这是最核心的类模板，它将一个数值和一个时间单位绑定在一起，实现了类型安全的时间长度表示。

#include <iostream>
#include <chrono>
using namespace std::chrono;

void TestDuration() {
    // 构造与观察
    milliseconds ms(1024);
    std::cout << ms.count() << " ms\n";

    // 算术运算
    seconds s = duration_cast<seconds>(milliseconds(2500) + milliseconds(500));
    std::cout << s.count() << " s\n";

    // 比较运算
    if (minutes(1) > seconds(30)) {
        std::cout << "1 分钟比 30 秒长\n";
    }

    // 单位转换
    seconds s2 = duration_cast<seconds>(milliseconds(1500));
    std::cout << s2.count() << " s (截断后)\n";
}

treat_as_floating_point

这是一个类型特征，用于判断一个类型是否应被视为浮点数，从而决定是否允许从高精度到低精度的隐式转换。

#include <iostream>
#include <chrono>
using namespace std::chrono;

void TestTAFP() {
    std::cout << std::boolalpha;
    std::cout << "treat_as_floating_point<int>: " 
              << treat_as_floating_point<int>::value << "\n"; // false
    std::cout << "treat_as_floating_point<double>: " 
              << treat_as_floating_point<double>::value << "\n"; // true

    seconds s(1);
    // 目标为 double -> 隐式转换 OK
    duration<double, std::milli> d1 = s;
    std::cout << "d1 (double 毫秒): " << d1.count() << " ms\n";

    // 目标为 int -> 必须显式转换
    duration<int, std::milli> d2 = duration_cast<milliseconds>(s);
    std::cout << "d2 (int 毫秒，显式转换): " << d2.count() << " ms\n";
}

duration_values

工具类模板，为给定的 Rep 类型提供了获取零值、最小值和最大值的统一静态接口。主要用于自定义类型支持。

时间点

time_point

将时钟和时间段结合起来，表示相对于该时钟纪元的一个具体时间点。

#include <iostream>
#include <chrono>
#include <thread>
using namespace std::chrono;

void TestTimePoint() {
    // 获取当前时间点
    system_clock::time_point now = system_clock::now();
    
    // 计算 1 小时后的时间点
    system_clock::time_point one_hour_later = now + hours(1);
    
    // 计算时间间隔
    auto diff = one_hour_later - now;
    std::cout << "时间间隔为 " << duration_cast<minutes>(diff).count() << " 分钟\n";

    // 休眠示例
    auto start = steady_clock::now();
    std::this_thread::sleep_for(milliseconds(100));
    auto end = steady_clock::now();
    std::cout << "休眠了 " << duration_cast<microseconds>(end - start).count() << " 微秒\n";
}

clock_time_conversion

在不同时钟的时间点之间进行转换的机制。C++20 中常用 clock_cast 简化操作。

#include <iostream>
#include <chrono>
using namespace std::chrono;

void TestCTC() {
    auto sys_now = system_clock::now();
    // 转换为 UTC 时间
    utc_clock::time_point utc_now = clock_cast<utc_clock>(sys_now);
    std::cout << "系统时间已转换为 UTC 时间\n";

    // 往返转换验证
    auto sys_now2 = clock_cast<system_clock>(utc_now);
    if (sys_now == sys_now2) {
        std::cout << "往返转换后时间点一致\n";
    }
}

时钟

C++11 的基础三时钟

这三个时钟覆盖了绝大多数日常使用场景。

C++20 新增的专业时钟

面向科学计算、卫星通信等专业领域。

• utc_clock: 协调世界时，处理跳秒。
• tai_clock: 国际原子时，无跳秒。
• gps_clock: 全球定位系统时。
• file_clock: 文件系统时间戳。
• local_t: 本地时间标记。

is_clock 与 is_clock_v

C++20 引入的类型特征，用于在编译期判断一个类型是否符合时钟的要求。

#include <iostream>
#include <chrono>
using namespace std::chrono;

void TestCheck() {
    std::cout << std::boolalpha;
    std::cout << "is_clock_v<system_clock>: " << is_clock_v<system_clock> << "\n"; // true
    std::cout << "is_clock_v<MyClass>: " << is_clock_v<MyClass> << "\n"; // false
}

日历

日历基础类型

C++20 引入，表示格里高利历中的基本日期元素。

• day: 月份中的某一天（1-31）
• month: 年份中的某个月（1-12）
• year: 年份
• weekday: 星期几
• last_spec: 标签类，表示最后一天

日历复合类型

由基础类型组合而成，用于表示完整的日期或特定规则。

• year_month_day: 完整的日期（如 2024-05-21）
• year_month_weekday: 某年第 N 个月的星期 W
• month_day: 忽略年份的月日组合

关键运算符与函数

日历类型之所以强大，很大程度上归功于重载的运算符。

• 创建运算符：/ 被重载用于组合年、月、日，顺序任意。
• 算术运算：加减 days, months, years。
• 流输出：大多数日历类型都重载了 <<，可以直接输出。

#include <iostream>
#include <chrono>
using namespace std::chrono;
using namespace std::literals;

int main() {
    // 创建日期的多种方式
    auto ymd1 = 2024y / May / 21d;
    std::cout << "ymd1 = " << ymd1 << "\n"; // 输出：2024-05-21

    // 日期算术
    auto ymd_next_month = ymd1 + months(1);
    std::cout << "下个月：" << ymd_next_month << "\n";

    // 特殊日期：某月最后一天
    auto last_day_of_feb_2024 = 2024y / February / last;
    std::cout << "2024 年 2 月最后一天：" << last_day_of_feb_2024 << "\n";

    return 0;
}

函数

时长与时间点操作函数

• duration_cast: 转换单位，截断取整。
• floor/ceil/round: 向下、向上或四舍五入到目标单位。
• time_point_cast: 转换时间点的内部时长单位。
• clock_cast: 不同时钟间转换。

输入/输出函数

C++20 增强了格式化能力，支持 from_stream 解析和 operator<< 输出。

测试实战

日期计算

以下代码展示了如何封装一个 Date 类，利用 <chrono> 处理闰年、星期及日期算术。

// Date.h 核心逻辑摘要
#include <chrono>
class Date {
private:
    std::chrono::year_month_day ymd_;
public:
    Date(int year, int month, int day) : ymd_(year / month / day) {}
    
    // 加天数
    Date operator+(const std::chrono::days& d) const {
        auto sd = std::chrono::sys_days{ymd_} + d;
        return Date{std::chrono::year_month_day{sd}};
    }
    
    // 判断闰年
    bool isLeapYear() const { return ymd_.year().is_leap(); }
};

性能测试

我们以内存池为例，对比其与直接向系统 new/delete 的性能差距。

// MPTest.cpp 核心逻辑摘要
#include <chrono>
#include "MemoryPool.h"
using namespace std::chrono;

template <typename AllocFunc, typename DeallocFunc>
double run_test(size_t iterations, AllocFunc alloc, DeallocFunc dealloc) {
    auto start = high_resolution_clock::now();
    for (size_t i = 0; i < iterations; ++i) {
        pointers.emplace_back(alloc());
    }
    for (void* p : pointers) {
        dealloc(p);
    }
    auto end = high_resolution_clock::now();
    return duration<double>(end - start).count();
}

int main() {
    const size_t ITERATIONS = 1000000;
    // 内存池测试
    FixedSizePool pool(256, 1024);
    double pool_time = run_test(ITERATIONS, [&pool]() { return pool.allocate(); }, ...);
    std::cout << "内存池耗时：" << pool_time << " 秒\n";

    // 直接 new/delete 测试
    double new_time = run_test(ITERATIONS, []() { return ::operator new(256); }, ...);
    std::cout << "new/delete 耗时：" << new_time << " 秒\n";
    return 0;
}

熟练运用 <chrono> 可以在时间计算、性能测试等多方面领域大展身手。通过编译期检查避免单位错误，利用单调时钟保证测量准确，配合 C++20 的日历功能处理复杂业务逻辑，是现代 C++ 开发者的必备技能。