C++高精度时间库——＜chrono＞

        在前面学习C语言我们就已经学习了C语言的时间库<time.h>。它操作简单、是全平台行为一致的时间库。但是它却存在着很多的问题——类型不安全，精度较低（通常为秒），扩展只能依赖编译器特制的宏。

        而现代项目中如果要进行性能测试、时间间隔计算的话，C语言的<time.h>显然是不够的。因此在C++11中，引入了<chrono>这个时间库。接下来我们就来一次学习一下。

        相关的英文文档为：Standard library header <chrono> (C++11) - cppreference.com

        相关的测试代码已经上传至作者的个人gitee：楼田莉子/CPP代码学习

目录

设计哲学

库中的单位

        时长单位（Duration Units）

        时钟单位（Clock Types）

        日历基础单位（Calendar Fundamentals）

        日历复合单位（Calendar Composites）

        时刻单位（Time of Day）

        时区单位（Time Zone）

        字面量单位（Literals）

模板类

        std::chrono::duration

  std::chrono::treat_as_floating_point

        std::chrono::duration_values

时间点

        time_point

        clock_time_conversion

时钟

        C++11 的基础三时钟

        C++20 新增的专业时钟

        辅助模板：is_clock 与 is_clock_v

日历

        日历基础类型

        日历复合类型

        关键运算符与函数

        代码示例：

函数

        时长（Duration）操作函数

        时间点（Time Point）操作函数

        日历（Calendar）操作函数

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

        字面量（Literals）运算符

测试

        日期计算

        性能测试

<chrono>设计哲学

        在C++11之前，我们处理时间基本靠 time_t、clock() 和 struct timespec。这种方式的问题在于：类型不安全。函数参数传递 time_t，你无法直观知道单位是秒还是毫秒；做时间运算时，极易因单位混淆导致bug

 <chrono> 库最伟大的贡献，就是引入了 编译期类型安全 和 精度无关 的时间处理模型。它将时间抽象为三个核心概念：

1. 时间段 (Duration)：由 数值 和 单位 组成的强类型。例如 std::chrono::seconds(10) 就是10秒，std::chrono::milliseconds(1000) 是1000毫秒，它们在类型上就不同，不能直接隐式转换，避免了单位混淆。
2. 时间点 (Time Point)：某个特定时钟上的一个点，由 时钟 (Clock) 和 时间段 (Duration) 共同定义。它本质上是从某个固定的纪元 (Epoch) 开始到现在的时间段。例如 std::chrono::system_clock::now() 返回的就是一个时间点。
3. 时钟 (Clock)：提供了获取当前时间点的入口 (now())，并定义了时间点的精度和纪元。标准提供了三种时钟（如文档所列），这是新手最容易踩坑的地方，下面我会重点讲。

库中的单位

        时长单位（Duration Units）

        这些是表示时间间隔的类型，基于duration模板定义。

        时钟单位（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秒。

        核心接口与表达式

        示例代码：

#define _CRT_SECURE_NO_WARNINGS #include<iostream> #include<chrono> #include <ratio>//提供编译期有理数算术的支持。 using namespace std::chrono; //duration 的基本操作 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。

核心规则与表达式

        示例代码：

#define _CRT_SECURE_NO_WARNINGS #include<iostream> #include<chrono> #include <ratio>//提供编译期有理数算术的支持。 using namespace std::chrono; //treat_as_floating_point 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 无缝协作。

#define _CRT_SECURE_NO_WARNINGS #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）。

核心接口与表达式

        示例代码：

#define _CRT_SECURE_NO_WARNINGS #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）。

        示例代码：

#define _CRT_SECURE_NO_WARNINGS #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 起就存在，覆盖了绝大多数日常使用场景。

        示例代码：

#define _CRT_SECURE_NO_WARNINGS #include <iostream> #include <chrono> #include <thread> using namespace std::chrono; //C++11的基础时钟 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 极大地扩展了时钟家族，引入了处理不同时间标准的能力，主要面向科学计算、卫星通信等专业领域。

        示例代码：

#define _CRT_SECURE_NO_WARNINGS #include <iostream> #include <chrono> #include <thread> using namespace std::chrono; //C++20的时钟 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 引入的一个类型特征，用于在编译期判断一个类型是否符合时钟的要求。

        示例代码：

#define _CRT_SECURE_NO_WARNINGS #include <iostream> #include <chrono> #include <thread> using namespace std::chrono; //C++20辅助模板——检测是否为时钟类型 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

#define _CRT_SECURE_NO_WARNINGS #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

#define _CRT_SECURE_NO_WARNINGS #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

#define _CRT_SECURE_NO_WARNINGS #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

#define _CRT_SECURE_NO_WARNINGS #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; }

        结果为：

        本期关于C++中<chrono>库的介绍就到这里了。熟练运用它可以在时间计算、性能测试灯多方面领域大展身手！

        如果你喜欢这期内容请点个赞谢谢。

封面图自取：