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

时钟单位（Clock Types）

时钟定义了时间的原点（纪元）和刻度，用于产生时间点。

日历基础单位（Calendar Fundamentals）

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

日历复合单位（Calendar Composites）

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

时刻单位（Time of Day）

将时长拆分为时、分、秒等，用于表示一天内的时间。

时区单位（Time Zone）

C++20 引入，用于处理时区、本地时间和转换。

字面量单位（Literals）

定义在 std::literals::chrono_literals 内联命名空间中，用于便捷书写。

模板类

std::chrono::duration

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

template<class Rep,class Period = std::ratio<1>> class duration;

• **Rep**：存储 tick 计数的算术类型，如 long long、int 或 double。
• **Period**：一个 std::ratio 类型，编译期指定每个 tick 代表的秒数。例如，std::ratio<1> 为 1 秒，std::milli 为 1/1000 秒。

核心接口与表达式

示例代码：

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

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

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

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

    // 4. 单位转换
    seconds s2 = duration_cast<seconds>(milliseconds(1500)); // 显式转换：1s
    std::cout << s2.count() << " s (截断后)\n"; // 输出：1 s
    duration<double, std::ratio<60>> d_min = seconds(90); // 隐式转换：1.5 分钟
    std::cout << d_min.count() << " 分钟\n"; // 输出：1.5 分钟

    // 5. 特殊值
    std::cout << "duration<int>::zero(): " << duration<int>::zero().count() << "\n";
}

结果为：

std::chrono::treat_as_floating_point

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

//C++11 定义
template< class Rep > struct treat_as_floating_point : std::is_floating_point<Rep> {};
//C++17 定义
template< class Rep > constexpr bool treat_as_floating_point_v = treat_as_floating_point<Rep>::value;

它继承自 std::is_floating_point，因此默认情况下，只有当 Rep 是 float、double、long double 时，其值为 true。

核心规则与表达式

示例代码：

#include<iostream>
#include<chrono>
#include <ratio>
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); // 1 秒

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

    // 2. 目标为 int (treat_as_floating_point == false) -> 隐式转换 ERROR
    // duration<int, milli> d2 = s; // 编译错误：存在截断风险

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

结果为：

std::chrono::duration_values

这是一个工具类模板，它为给定的 Rep 类型提供了获取零值、最小值和最大值的统一静态接口。

template<class Rep> struct duration_values;

核心静态接口与表达式

主要用途：它主要被标准库内部用于实现 duration::zero()、duration::min() 和 duration::max() 成员函数。例如，duration::zero() 的实现通常会返回 duration(duration_values<Rep>::zero())。

自定义类型支持：如果你想用自定义类型（如高精度有理数类）作为 duration 的 Rep，可以通过特化 duration_values 来告知标准库如何获取该类型的这些边界值，从而使你的类型能与 <chrono 无缝协作。

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

void TestDurationV()
{
    // 1. 获取基本类型的边界值
    std::cout << "duration_values<int>::zero(): " << duration_values<int>::zero() << "\n";
    std::cout << "duration_values<int>::min(): " << duration_values<int>::min() << "\n";
    std::cout << "duration_values<int>::max(): " << duration_values<int>::max() << "\n";
    std::cout << "duration_values<double>::zero(): " << duration_values<double>::zero() << "\n";
    std::cout << "duration_values<double>::min(): " << duration_values<double>::min() << "\n";
    std::cout << "duration_values<double>::max(): " << duration_values<double>::max() << "\n";

    // 2. 它们与 duration 的成员函数返回的时长对象的关系
    // 以下两者本质上是等价的
    auto zero_dur1 = duration<int>::zero(); // 返回 duration<int> 对象
    auto zero_dur2 = duration<int>(duration_values<int>::zero()); // 显式构造
    std::cout << "duration<int>::zero().count(): " << zero_dur1.count() << "\n";
    std::cout << "手动构造的零时长 count(): " << zero_dur2.count() << "\n";
}

结果为：

时间点

time_point

这是最核心的类模板，它将一个时钟（Clock）和一个时长（Duration）结合起来，表示相对于该时钟纪元（epoch）的一个具体时间点。

template<class Clock, class Duration = typename Clock::duration> class time_point;

• **Clock**：关联的时钟类型，如 system_clock、steady_clock。它定义了时间点的原点（纪元）。
• **Duration**：用于度量从纪元到该时间点的时长的类型，默认为时钟的 duration 类型（通常是 microseconds 或 nanoseconds）。

核心接口与表达式

示例代码：

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

void TestTimePoint()
{
    // 1. 获取当前时间点（基于 system_clock）
    system_clock::time_point now = system_clock::now();
    std::cout << "当前时间点已获取\n";

    // 2. 获取从纪元到现在的时长
    auto since_epoch = now.time_since_epoch();
    std::cout << "从纪元至今已过去 " << duration_cast<seconds>(since_epoch).count() << " 秒\n";

    // 3. 时间点算术：计算 1 小时后的时间点
    system_clock::time_point one_hour_later = now + hours(1);
    std::cout << "1 小时后的时间点已计算\n";

    // 4. 时间点减法：计算两个时间点的间隔
    auto diff = one_hour_later - now;
    std::cout << "时间间隔为 " << duration_cast<minutes>(diff).count() << " 分钟\n";

    // 5. 时间点比较
    if (one_hour_later > now) {
        std::cout << "1 小时后确实晚于现在\n";
    }

    // 6. 单位转换示例
    auto now_ms = time_point_cast<milliseconds>(now);
    std::cout << "当前时间点的毫秒精度计数：" << now_ms.time_since_epoch().count() << " ms\n";

    // 7. 休眠示例（演示时间点与实际等待）
    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

这是一个特性类（trait），它提供了在不同时钟的时间点之间进行转换的机制。在 C++20 中，随着新时钟（如 utc_clock）的引入，这个类变得尤为重要。标准库通过特化为特定的时钟对提供转换逻辑。

template<class Dest, class Source> struct clock_time_conversion;

• Dest 和 Source：通常是时钟类型。这个模板本身没有定义通用的转换，而是通过为特定的时钟对提供特化来实现转换逻辑。

核心接口与表达式

这个类的主要接口是一个函数调用运算符（operator()），它接受一个源时钟的时间点，并返回目标时钟的时间点（或是一个能转换为时间点的类型，如 sys_time）。

示例代码：

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

void TestCTC()
{
    // 获取当前系统时间点（UTC 时间）
    auto sys_now = system_clock::now();

    // 1. 使用 clock_cast 将系统时间转换为 UTC 时钟的时间点
    utc_clock::time_point utc_now = clock_cast<utc_clock>(sys_now);
    std::cout << "系统时间已转换为 UTC 时间\n";

    // 2. 使用 clock_time_conversion 直接进行转换（等价于 clock_cast）
    clock_time_conversion<utc_clock, system_clock> converter;
    utc_clock::time_point utc_now2 = converter(sys_now);
    std::cout << "使用转换器再次转换成功\n";

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

    // 4. 与 TAI 时间互转（展示不同时钟系统）
    tai_clock::time_point tai_now = clock_cast<tai_clock>(sys_now);
    std::cout << "系统时间已转换为 TAI 时间\n";

    // 计算当前 UTC 和 TAI 的偏移（通常为 37 秒，因跳秒而变）
    auto offset = tai_now - clock_cast<tai_clock>(utc_now);
    std::cout << "当前 UTC 与 TAI 偏移：" << duration_cast<seconds>(offset).count() << " 秒\n";
}

结果为：

时钟

在 <chrono 中，一个时钟类通常提供以下核心接口（以静态成员的形式）：

C++11 的基础三时钟

这三个时钟从 C++11 起就存在，覆盖了绝大多数日常使用场景。

示例代码：

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

void TestClocks11()
{
    // 1. system_clock: 获取当前时间点并转换为可读形式
    auto sys_now = system_clock::now();
    std::time_t sys_now_c = system_clock::to_time_t(sys_now);
    std::cout << "system_clock 当前时间：" << std::ctime(&sys_now_c);

    // 2. steady_clock: 测量代码块执行时间
    auto start = steady_clock::now();
    std::this_thread::sleep_for(milliseconds(100)); // 模拟工作
    auto end = steady_clock::now();
    auto elapsed = duration_cast<microseconds>(end - start);
    std::cout << "steady_clock 测量耗时：" << elapsed.count() << " us\n";

    // 3. high_resolution_clock: 最高精度计时（用法与 steady_clock 类似）
    auto hr_start = high_resolution_clock::now();
    // ... 一些工作 ...
    auto hr_end = high_resolution_clock::now();
    auto hr_elapsed = duration_cast<nanoseconds>(hr_end - hr_start);
    std::cout << "high_resolution_clock 耗时：" << hr_elapsed.count() << " ns\n";

    // 4. 检查时钟的稳定性
    std::cout << std::boolalpha;
    std::cout << "system_clock 是否稳定：" << system_clock::is_steady << "\n";
    std::cout << "steady_clock 是否稳定：" << steady_clock::is_steady << "\n";
}

结果为：

C++20 新增的专业时钟

C++20 极大地扩展了时钟家族，引入了处理不同时间标准的能力，主要面向科学计算、卫星通信等专业领域。

示例代码：

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

void TestClocks20()
{
    // 1. 获取当前 UTC 时间
    auto utc_now = utc_clock::now();
    std::cout << "UTC 时间已获取\n";

    // 2. 获取当前 TAI 时间
    auto tai_now = tai_clock::now();
    std::cout << "TAI 时间已获取\n";

    // 3. 时钟转换 (C++20 的 clock_cast)
    auto sys_from_utc = clock_cast<system_clock>(utc_now);
    auto sys_from_tai = clock_cast<system_clock>(tai_now);
    std::cout << "UTC 和 TAI 时间已转换为 system_clock\n";

    // 4. file_clock 的使用
    auto file_now = file_clock::now();
    auto sys_from_file = clock_cast<system_clock>(file_now); // 或 clock_cast<system_clock>
    std::cout << "文件时间已转换为系统时间\n";

    // 5. 注意：local_t 不能直接调用 now()
    // auto local_now = local_t::now(); // 编译错误
    // 它通常与 zoned_time 配合使用
}

示例代码：

辅助模板：is_clock 与 is_clock_v

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

示例代码：

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

class MYclass {};

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

结果为：

日历

日历基础类型

这些是构成日期的基本原子类型，每个都封装了特定的日历字段。

日历复合类型

这些类型组合基础元素，表示更丰富的日期概念。

关键运算符与函数

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

代码示例：

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <chrono>
using namespace std::chrono;
using namespace std::literals; // 用于 "y" 和 "d" 字面量

int main()
{
    // 1. 创建日期的多种方式
    auto ymd1 = 2024y / May / 21d; // 最直观
    auto ymd2 = 21d / May / 2024; // 顺序可调
    auto ymd3 = year_month_day{ 2024y, May, 21d }; // 显式构造
    std::cout << "ymd1 = " << ymd1 << "\n"; // 输出：2024-05-21
    std::cout << "ymd2 = " << ymd2 << "\n";
    std::cout << "ymd3 = " << ymd3 << "\n";

    // 2. 访问日期字段
    std::cout << "年份：" << ymd1.year() << "\n";
    std::cout << "月份：" << ymd1.month() << "\n";
    std::cout << "日：" << ymd1.day() << "\n";

    // 3. 日期算术
    auto ymd_next_month = ymd1 + months(1);
    std::cout << "下个月：" << ymd_next_month << "\n"; // 2024-06-21
    auto ymd_next_year = ymd1 + years(1);
    std::cout << "明年：" << ymd_next_year << "\n"; // 2025-05-21

    // 将 year_month_day 显式转换为 sys_days，进行天数算术，再隐式转换回来
    auto ymd_next_week = year_month_day{ sys_days{ymd1} + days(7) };
    std::cout << "一周后：" << ymd_next_week << "\n"; // 2024-05-28

    // 4. 处理特殊日期：某月最后一天
    auto last_day_of_feb_2024 = 2024y / February / last;
    std::cout << "2024 年 2 月最后一天：" << last_day_of_feb_2024 << "\n"; // 2024-02-29 (闰年)
    std::cout << "那天是星期几？" << weekday{ last_day_of_feb_2024 } << "\n"; // 转换为 weekday

    // 5. 处理复杂规则：某月的第 N 个星期 W
    auto third_wed_may_2024 = 2024y / May / Wednesday[3];
    std::cout << "2024 年 5 月第三个星期三：" << third_wed_may_2024 << "\n";

    // 6. 检查日期有效性
    year_month_day invalid_date = 2024y / February / 30d;
    std::cout << "2024-02-30 有效吗？" << std::boolalpha << invalid_date.ok() << "\n"; // false

    // 7. 转换为 time_point (用于与 system_clock 交互)
    sys_days tp = sys_days{ ymd1 }; // 转换为基于 days 的时间点
    std::cout << "时间点 (自纪元天数): " << tp.time_since_epoch().count() << " 天\n";

    // 8. 两个日期相减得到天数间隔
    auto xmas = 2024y / December / 25d;
    auto days_until_xmas = sys_days{ xmas } - sys_days{ ymd1 };
    std::cout << "距离 2024 年圣诞节还有：" << days_until_xmas.count() << " 天\n";

    // 9. 使用 weekday 计算下一个周五
    weekday today = weekday{ ymd1 }; // 2024-05-21 是星期二
    weekday fri = Friday;
    auto days_until_fri = (fri - today).count(); // weekday 差值
    if (days_until_fri <= 0) days_until_fri += 7;
    std::cout << "下一个周五在 " << days_until_fri << " 天后\n";

    return 0;
}

结果为：

函数

时长（Duration）操作函数

这些函数用于操作 duration 对象，进行转换、取整和算术运算。

时间点（Time Point）操作函数

这些函数用于操作 time_point 对象，进行算术、转换和取整。

日历（Calendar）操作函数

C++20 引入，用于操作日期类型，提供算术和比较功能。每个主要类型都有一组对应的运算符。

输入/输出（I/O）函数

这些函数用于将 <chrono 类型格式化输出到流，或从流解析。

字面量（Literals）运算符

定义在内联命名空间 std::literals::chrono_literals 中，用于便捷书写时长和年份。

测试

日期计算

以下代码需要 C++20 才能编译通过

Date.h

#include <chrono>
#include <iostream>
#include <string>
#include< cassert >

class Date {
private:
    std::chrono::year_month_day ymd_;
public:
    // 1. 构造函数
    // 从 std::chrono::year_month_day 构造（隐式转换允许）
    Date(const std::chrono::year_month_day& ymd) : ymd_(ymd) { 
        if (!ymd_.ok()) { 
            throw std::invalid_argument("Invalid date"); 
        } 
    }
    // 从年、月、日整数构造
    Date(int year, int month, int day) : Date(std::chrono::year{ year } / month / day) { }

    // 2. 静态工厂：获取当前日期
    static Date today() {
        auto now = std::chrono::system_clock::now();
        auto today_days = std::chrono::floor<std::chrono::days>(now);
        return Date{ std::chrono::year_month_day{today_days} };
    }

    // 3. 访问器
    int year() const { return static_cast<int>(ymd_.year()); }
    unsigned month() const { return static_cast<unsigned>(ymd_.month()); }
    unsigned day() const { return static_cast<unsigned>(ymd_.day()); }
    // 获取星期几 (Sunday = 0, Monday = 1, ..., Saturday = 6)
    unsigned weekday() const {
        std::chrono::weekday wd{ std::chrono::sys_days{ymd_} };
        return wd.c_encoding(); // 返回 0-6
    }
    // 判断是否为闰年
    bool isLeapYear() const { return ymd_.year().is_leap(); }

    // 4. 日期算术运算符
    // 加天数
    Date operator+(const std::chrono::days& d) const {
        auto sd = std::chrono::sys_days{ ymd_ } + d;
        return Date{ std::chrono::year_month_day{sd} };
    }
    // 减天数
    Date operator-(const std::chrono::days& d) const { return *this + (-d); }
    // 加月份
    Date operator+(const std::chrono::months& m) const {
        auto new_ymd = ymd_ + m; // 处理可能的无效日期（如 1 月 31 日 + 1 个月 = 2 月 31 日，会调整到 2 月最后一天）
        if (!new_ymd.ok()) {
            new_ymd = new_ymd.year() / new_ymd.month() / std::chrono::last;
        }
        return Date{ new_ymd };
    }
    // 减月份
    Date operator-(const std::chrono::months& m) const { return *this + (-m); }
    // 加年份
    Date operator+(const std::chrono::years& y) const {
        auto new_ymd = ymd_ + y; // 处理闰年 2 月 29 日的情况
        if (!new_ymd.ok()) {
            new_ymd = new_ymd.year() / new_ymd.month() / std::chrono::last;
        }
        return Date{ new_ymd };
    }
    // 减年份
    Date operator-(const std::chrono::years& y) const { return *this + (-y); }

    // 复合赋值运算符（可选）
    Date& operator+=(const std::chrono::days& d) { return *this = *this + d; }
    Date& operator-=(const std::chrono::days& d) { return *this = *this - d; }
    Date& operator+=(const std::chrono::months& m) { return *this = *this - m; }
    Date& operator-=(const std::chrono::months& m) { return *this = *this - m; }
    Date& operator+=(const std::chrono::years& y) { return *this = *this + y; }
    Date& operator-=(const std::chrono::years& y) { return *this = *this - y; }

    // 5. 比较运算符（C++20 可以自动生成，但为清晰显式声明）
    auto operator<=>(const Date&) const = default; // C++20 三路比较，自动生成所有关系运算符

    // 6. 差值计算
    // 返回两个日期相差的天数（忽略时间部分）
    std::chrono::days daysUntil(const Date& other) const {
        return std::chrono::sys_days{ other.ymd_ } - std::chrono::sys_days{ ymd_ };
    }
    // 返回两个日期相差的完整月份数（近似，基于日历月）
    // 注意：这不是一个精确的物理时间差，而是日历上的月份差。
    int monthsUntil(const Date& other) const {
        // 简化实现：将年份差 * 12 + 月份差，再根据日进行调整
        int y1 = year(), m1 = month(), d1 = day();
        int y2 = other.year(), m2 = other.month(), d2 = other.day();
        int month_diff = (y2 - y1) * 12 + (m2 - m1);
        // 如果结束日期的日号小于开始日期的日号，则不满整月
        if (d2 < d1) {
            --month_diff;
        }
        return month_diff;
    }

    // 7. 友元输出运算符
    friend std::ostream& operator<<(std::ostream& os, const Date& date) {
        os << date.year() << '-' << (date.month() < 10 ? "0" : "") << date.month() << '-' << (date.day() < 10 ? "0" : "") << date.day();
        return os;
    }

    // 获取内部 year_month_day 的引用（用于需要直接操作底层类型的场景）
    const std::chrono::year_month_day& get_ymd() const { return ymd_; }
};

DateTest.cpp

#include"Date.h"
using namespace std::chrono_literals; // 用于 h, min, s, ms, us, ns, y

void testDate() {
    std::cout << "=== 开始测试 Date 类 ===\n";

    // 1. 构造函数与 today()
    std::cout << "1. 构造函数测试:\n";
    Date d1(2024, 5, 21);
    std::cout << " d1: " << d1 << "\n";
    assert(d1.year() == 2024 && d1.month() == 5 && d1.day() == 21);
    auto d_today = Date::today();
    std::cout << " Today: " << d_today << "\n";

    // 2. 无效日期抛出异常
    std::cout << "2. 无效日期测试 (2024-02-30): ";
    try {
        Date invalid(2024, 2, 30);
        std::cout << "FAILED: 未抛出异常\n";
    } catch (const std::invalid_argument& e) {
        std::cout << "PASSED: 捕获异常 - " << e.what() << "\n";
    } catch (...) {
        std::cout << "FAILED: 捕获到未知异常\n";
    }

    // 3. 闰年判断
    std::cout << "3. 闰年判断测试:\n";
    assert(Date(2024, 1, 1).isLeapYear() == true);
    assert(Date(2023, 1, 1).isLeapYear() == false);
    assert(Date(2000, 1, 1).isLeapYear() == true);
    assert(Date(1900, 1, 1).isLeapYear() == false);
    std::cout << " 所有闰年判断通过\n";

    // 4. 星期几
    std::cout << "4. 星期几测试:\n";
    // 2024-05-21 是星期二 (ISO: 2, C: 2? 需要查证，我们的 weekday 返回 c_encoding)
    // 根据常识，2024-05-21 是星期二，在 weekday 中周二对应 1（如果周日是 0，周一是 1，周二是 2）
    // 但 c_encoding() 周日=0，周一=1，周二=2，周三=3，周四=4，周五=5，周六=6
    assert(Date(2024, 5, 21).weekday() == 2); // 星期二
    assert(Date(2024, 5, 22).weekday() == 3); // 星期三
    assert(Date(2024, 5, 19).weekday() == 0); // 星期日
    std::cout << " 所有星期几判断通过\n";

    // 5. 日期算术
    std::cout << "5. 日期算术测试:\n";
    Date d2(2024, 5, 21);
    auto d_plus_7 = d2 + std::chrono::days(7);
    std::cout << " " << d2 << " + 7 days = " << d_plus_7 << "\n";
    assert(d_plus_7 == Date(2024, 5, 28));
    auto d_plus_1m = d2 + std::chrono::months(1);
    std::cout << " " << d2 << " + 1 month = " << d_plus_1m << "\n";
    assert(d_plus_1m == Date(2024, 6, 21));
    auto d_plus_1y = d2 + std::chrono::years(1);
    std::cout << " " << d2 << " + 1 year = " << d_plus_1y << "\n";
    assert(d_plus_1y == Date(2025, 5, 21));

    // 边界测试：月末
    Date d3(2024, 1, 31);
    auto d_plus_1m_jan = d3 + std::chrono::months(1);
    std::cout << " " << d3 << " + 1 month = " << d_plus_1m_jan << "\n";
    assert(d_plus_1m_jan == Date(2024, 2, 29)); // 2024 是闰年，所以是 2 月 29 日
    Date d4(2023, 1, 31);
    auto d_plus_1m_jan_nonleap = d4 + std::chrono::months(1);
    std::cout << " " << d4 << " + 1 month = " << d_plus_1m_jan_nonleap << "\n";
    assert(d_plus_1m_jan_nonleap == Date(2023, 2, 28)); // 2023 非闰年，2 月 28 日

    // 跨年测试
    Date d5(2024, 12, 15);
    auto d_plus_2m = d5 + std::chrono::months(2);
    std::cout << " " << d5 << " + 2 months = " << d_plus_2m << "\n";
    assert(d_plus_2m == Date(2025, 2, 15));

    // 6. 比较运算符
    std::cout << "6. 比较运算符测试:\n";
    Date d6a(2024, 5, 21);
    Date d6b(2024, 5, 22);
    Date d6c(2024, 5, 21);
    assert(d6a == d6c);
    assert(d6a != d6b);
    assert(d6a < d6b);
    assert(d6a <= d6c);
    assert(d6b > d6a);
    assert(d6b >= d6c);
    std::cout << " 所有比较运算符通过\n";

    // 7. 差值计算
    std::cout << "7. 差值计算测试:\n";
    Date d7_start(2024, 5, 21);
    Date d7_end(2024, 12, 25);
    auto days_diff = d7_start.daysUntil(d7_end);
    std::cout << " " << d7_start << " 到 " << d7_end << " 相差 " << days_diff.count() << " 天\n";
    assert(days_diff.count() == 218); // 手工验证 5 月剩余 10 天 + 6 月 30 + 7 月 31 + 8 月 31 + 9 月 30 + 10 月 31 + 11 月 30 + 12 月 25 = 218
    auto months_diff = d7_start.monthsUntil(d7_end);
    std::cout << " " << d7_start << " 到 " << d7_end << " 相差 " << months_diff << " 个整月\n";
    assert(months_diff == 7); // 5 月 21 日到 12 月 21 日是 7 个月，到 12 月 25 日超过 21 日，所以仍是 7 个整月

    // 跨年差值
    Date d7_start2(2024, 12, 25);
    Date d7_end2(2025, 1, 10);
    auto days_diff2 = d7_start2.daysUntil(d7_end2);
    std::cout << " " << d7_start2 << " 到 " << d7_end2 << " 相差 " << days_diff2.count() << " 天\n";
    assert(days_diff2.count() == 16); // 12 月剩余 7 天 + 1 月 10 天 = 16

    // 8. 复合赋值
    std::cout << "8. 复合赋值测试:\n";
    Date d8(2024, 5, 21);
    d8 += std::chrono::days(10);
    std::cout << " +=10 天：" << d8 << "\n";
    assert(d8 == Date(2024, 5, 31));
    d8 += std::chrono::months(1);
    std::cout << " +=1 月：" << d8 << "\n";
    assert(d8 == Date(2024, 6, 30)); // 5 月 31 日 +1 月 -> 6 月 30 日
    d8 -= std::chrono::years(1);
    std::cout << " -=1 年：" << d8 << "\n";
    assert(d8 == Date(2023, 6, 30));

    std::cout << "=== 所有测试通过 ===\n";
}

int main() {
    testDate();
    return 0;
}

结果为：

性能测试

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

MemoryPool.h

#pragma once
#include <vector>
#include <cassert>
#include <iostream>
using std::vector;
using std::cout;
using std::endl;

namespace MyMemoryPool {
    // 内存对齐：向上取整到指定对齐值（align 必须是 2 的幂）
    constexpr inline size_t align_up(size_t n, size_t align) {
        return (n + (align - 1)) & ~(align - 1);
    }

    // 固定大小内存池，每个块大小相同，按页管理
    class FixedSizePool {
    public:
        // 构造函数：指定块大小和每页块数（默认 1024）
        explicit FixedSizePool(size_t blockSize, size_t blockPerPage = 1024)
            : block_Size(adjust_block_size(blockSize)),
              block_Per_Page(blockPerPage),
              free_list(nullptr),
              total_allocations(0),
              total_deallocations(0),
              page_count(0) {}

        // 析构函数：释放所有已分配的页
        ~FixedSizePool() {
            for (void* page : Pages) {
                ::operator delete[](page); // 全局释放，避免调用析构函数
            }
        }

        // 分配一个块
        void* allocate() {
            if (!free_list) // 空闲链表为空，需要扩充新页
            {
                expand();
            }
            Node* head = free_list;
            free_list = head->next;
            ++total_allocations;
            return head;
        }

        // 回收一个块
        void deallocate(void* p) {
            if (!p) return;
            Node* node = static_cast<Node*>(p);
            node->next = free_list;
            free_list = node;
            ++total_deallocations;
        }

        // 获取块大小
        size_t Get_block_Size() const { return block_Size; }
        size_t Get_block_Per_Page() const { return block_Per_Page; }

        // 打印统计信息
        void print_stats() const {
            std::cout << "内存池统计:" << std::endl;
            std::cout << " 总分配次数：" << total_allocations << std::endl;
            std::cout << " 总释放次数：" << total_deallocations << std::endl;
            std::cout << " 当前使用中：" << (total_allocations - total_deallocations) << std::endl;
            std::cout << " 页数量：" << page_count << std::endl;
            std::cout << " 内存使用量：" << (page_count * block_Size * block_Per_Page) << " 字节" << std::endl;
        }

    private:
        // 结点结构，用于空闲链表
        struct Node {
            Node* next;
        };

        // 申请新的一页内存，并将其切分为多个块链入空闲链表
        void expand() {
            size_t page_bytes = block_Size * block_Per_Page;
            char* page = static_cast<char*>(::operator new[](page_bytes));
            Pages.push_back(page);
            ++page_count;

            // 将当前页的所有块串联成链表
            for (size_t i = 0; i < block_Per_Page; ++i) {
                char* block = page + i * block_Size;
                Node* n = reinterpret_cast<Node*>(block);
                n->next = free_list;
                free_list = n;
            }
        }

        // 调整块大小：确保至少 sizeof(void*) 并正确对齐
        size_t adjust_block_size(size_t s) const {
            size_t min_size = sizeof(void*);
            return align_up(s < min_size ? min_size : s, alignof(void*));
        }

        Node* free_list; // 空闲链表头
        size_t block_Size; // 实际块大小（已调整）
        size_t block_Per_Page; // 每页块数
        vector<void*> Pages; // 记录所有分配过的页，用于析构时释放

        // 统计变量
        size_t total_allocations;
        size_t total_deallocations;
        size_t page_count;
    };
}

MPTest.cpp

#include <iostream>
#include <chrono>
#include <vector>
#include "MemoryPool.h"
using namespace MyMemoryPool;
using namespace std::chrono;

// 通用测试模板：执行 iterations 次分配和释放，返回耗时（秒）
template <typename AllocFunc, typename DeallocFunc>
double run_test(size_t iterations, AllocFunc alloc, DeallocFunc dealloc) {
    std::vector<void*> pointers;
    pointers.reserve(iterations);
    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();
    duration<double> elapsed = end - start;
    return elapsed.count();
}

int main() {
    const size_t BLOCK_SIZE = 256; // 每个块 256 字节
    const size_t BLOCKS_PER_PAGE = 1024; // 每页 1024 块
    const size_t ITERATIONS = 1000000; // 分配/释放 100 万次

    std::cout << "===== 性能对比测试 =====\n";
    std::cout << "块大小：" << BLOCK_SIZE << " 字节\n";
    std::cout << "每页块数：" << BLOCKS_PER_PAGE << "\n";
    std::cout << "分配/释放次数：" << ITERATIONS << "\n\n";

    // 1. 内存池测试
    {
        FixedSizePool pool(BLOCK_SIZE, BLOCKS_PER_PAGE);
        double pool_time = run_test(ITERATIONS, [&pool]() { return pool.allocate(); }, [&pool](void* p) { pool.deallocate(p); });
        std::cout << "内存池耗时：" << pool_time << " 秒\n";
        pool.print_stats();
    }
    std::cout << "\n";

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

    return 0;
}

结果为：

掌握 chrono 库不仅能提升时间计算的准确性，更是进行底层性能剖析的关键工具。熟练运用它可以在时间计算、性能测试等多方面领域大展身手！