C++时间处理完全指南：从chrono到C风格API #
chrono库概述 #
C++11引入的chrono库提供了现代化的时间处理方案，包含三种时钟类型：system_clock、steady_clock和high_resolution_clock。
首先介绍下 C++ 标准中的 chrono 库。
chrono 是一个关于时间的库，起源于 boost，现在是 C++ 的标准，现在的 C++ 标准好多都是源于 boost，要进标准的特性似乎都会先在 boost 试验一番。
首先看一下使用 chrono 简单计时的示例代码：
void func() {
// 计时
std::chrono::time_point<std::chrono::high_resolution_clock> begin = high_resolution_clock::now();
std::this_thread::sleep_for(std::chrono::milliseconds(20));
auto end = high_resolution_clock::now();
cout << "time " << duration_cast<milliseconds>(end - begin).count() << endl;
}
chrono 中有三个概念：duration、time_point、clock。
duration #
表示一段时间，如三分钟、三秒等，定义如下：
template <class _Rep, class _Period = ratio<1>> class duration;
ratio 的定义如下：
template <intmax_t N, intmax_t D = 1> class ratio;
Rep 表示数据类型，如 int、long 等，Period 表示时间单位，N 是分子，D 是分母。直接看例子：
using atto = ratio<1, 1000000000000000000LL>;
using femto = ratio<1, 1000000000000000LL>;
using pico = ratio<1, 1000000000000LL>;
using nano = ratio<1, 1000000000>;
using micro = ratio<1, 1000000>;
using milli = ratio<1, 1000>;
using centi = ratio<1, 100>;
using deci = ratio<1, 10>;
using deca = ratio<10, 1>;
using hecto = ratio<100, 1>;
using kilo = ratio<1000, 1>;
using mega = ratio<1000000, 1>;
using giga = ratio<1000000000, 1>;
using tera = ratio<1000000000000LL, 1>;
using peta = ratio<1000000000000000LL, 1>;
using exa = ratio<1000000000000000000LL, 1>;
using nanoseconds = duration<long long, nano>;
using microseconds = duration<long long, micro>;
using milliseconds = duration<long long, milli>;
using seconds = duration<long long>;
using minutes = duration<int, ratio<60>>;
using hours = duration<int, ratio<3600>>;
using hours2 = duration<int, ratio<3600, 1>>;
using hours2 = duration<int, ratio<7200, 2>>;
通过这些例子可以看出，ratio 的默认时间单位是 1 秒。以小时为例，一小时等于 3600 秒，3600 / 1 == 7200 / 2 == 3600，所以 hours == hours2 == hours3。
标准库还提供了 duration_cast 用于转换各种 duration：
template <class _To, class _Rep, class _Period, enable_if_t<_Is_duration_v<_To>, int> = 0>
constexpr _To duration_cast(const duration<_Rep, _Period>&) noexcept(
is_arithmetic_v<_Rep>&& is_arithmetic_v<typename _To::rep>);
template <class _Ty>
_INLINE_VAR constexpr bool _Is_duration_v = _Is_specialization_v<_Ty, duration>;
template <class _Ty>
_INLINE_VAR constexpr bool is_arithmetic_v = // determine whether _Ty is an arithmetic type
is_integral_v<_Ty> || is_floating_point_v<_Ty>;
函数看起来很繁琐，直接看示例代码：
void func() {
auto sec = std::chrono::seconds(10);
auto mill = std::chrono::duration_cast<std::chrono::milliseconds>(sec);
cout << sec.count() << endl; // 返回多少秒
cout << mill.count() << endl; // 返回多少毫秒
}
// 输出：10 10000
time_point #
用来表示某个具体时间点，定义如下：
template <class _Clock, class _Duration = typename _Clock::duration> class time_point;
使用方式：
void func() {
std::chrono::time_point<std::chrono::system_clock, std::chrono::milliseconds> tp(std::chrono::seconds(12));
cout << tp.time_since_epoch().count() << endl;
std::time_t t = system_clock::to_time_t(tp);
cout << "time " << ctime(&t) << endl;
}
// 输出：12000 time Thu Jan 1 08:00:12 1970
这里有个函数 time_since_epoch()，表示这个 time_point 距离元年（1970 年 1 月 1 日）所经过的 duration。
time_point 也有各种表示方式，类似于 duration，提供了转换函数 time_point_cast()：
void func() {
time_point<system_clock, milliseconds> tp(seconds(12));
cout << tp.time_since_epoch().count() << endl;
time_point<system_clock, seconds> tp2 = time_point_cast<seconds>(tp);
cout << tp2.time_since_epoch().count() << endl;
}
// 输出：12000 12
Clocks #
这里有三种时钟：
system_clock #
表示当前的系统时钟，有三个函数：
- now()：表示当前时间的 time_point
- to_time_t()：将 time_point 转换为 time_t 秒
- from_time_t()：将 time_t 转换为 time_point
源码如下：
struct system_clock {
using rep = long long;
using period = ratio_multiply<ratio<_XTIME_NSECS_PER_TICK, 1>, nano>;
using duration = chrono::duration<rep, period>;
using time_point = chrono::time_point<system_clock>;
static constexpr bool is_steady = false;
_NODISCARD static time_point now() noexcept {
return time_point(duration(_Xtime_get_ticks()));
}
_NODISCARD static __time64_t to_time_t(const time_point& _Time) noexcept {
return static_cast<__time64_t>(_Time.time_since_epoch().count() / _XTIME_TICKS_PER_TIME_T);
}
_NODISCARD static time_point from_time_t(__time64_t _Tm) noexcept {
return time_point(duration(_Tm * _XTIME_TICKS_PER_TIME_T));
}
};
steady_clock #
表示稳定的时钟，只有一个函数 now()，后一次调用 now() 肯定比上一次调用 now() 的返回值大，不受系统时间修改的影响。
源码如下：
struct steady_clock {
using rep = long long;
using period = nano;
using duration = nanoseconds;
using time_point = chrono::time_point<steady_clock>;
static constexpr bool is_steady = true;
_NODISCARD static time_point now() noexcept {
const long long _Freq = _Query_perf_frequency(); // 不会改变，系统启动后
const long long _Ctr = _Query_perf_counter();
static_assert(period::num == 1, "This assumes period::num == 1.");
const long long _Whole = (_Ctr / _Freq) * period::den;
const long long _Part = (_Ctr % _Freq) * period::den / _Freq;
return time_point(duration(_Whole + _Part));
}
};
使用方式和之前的相同：
void func() {
// 计时
std::chrono::time_point<std::chrono::steady_clock> begin = steady_clock::now();
std::this_thread::sleep_for(std::chrono::milliseconds(20));
auto end = steady_clock::now();
cout << "time " << duration_cast<milliseconds>(end - begin).count() << endl;
}
high_resolution_clock #
表示高精度时钟，是系统可用的最高精度的时钟，其实就是 system_clock 或者 steady_clock 的别名：
using high_resolution_clock = steady_clock;
介绍完 C++ 的 chrono 库，再来看 C 语言的各种时间相关 API。
C 语言时间相关函数 #
clock #
可以通过 C 语言的 clock 拿到程序执行时处理器所使用的时钟数来计时：
clock_t clock(void);
该函数返回程序执行起（一般为程序的开头），处理器时钟所使用的时间。获取 CPU 所使用的秒数，除以 CLOCKS_PER_SEC 即可。返回的 clock_t 其实是 long 类型的重命名。
使用方式：
void func() {
clock_t start_t = clock();
cout << start_t << " 个时钟 \n";
for (int i = 0; i < 100000000; i++) {}
clock_t end_t = clock();
cout << end_t << " 个时钟 \n";
cout << "循环的秒数：" << (double)(end_t - start_t) / CLOCKS_PER_SEC << endl;
}
获取当前时间戳（单位为秒） #
void func() {
struct timeval time;
gettimeofday(&time, NULL);
cout << time.tv_sec << " s \n";
}
也可以使用 time 函数：
time_t time(time_t *time);
该函数返回系统的当前日历时间，返回的是自 1970 年 1 月 1 日以来所经过的秒数。
time_t 其实就是一个整数类型，是 int64_t 的重命名，该函数直接使用返回值就好，参数一般传空即可。
获取当前时间戳（单位为毫秒） #
void func() {
struct timeval time;
gettimeofday(&time, NULL);
cout << time.tv_sec * 1000 + time.tv_usec / 1000 << " ms \n";
}
显示当前的系统时间 #
可以使用 ctime 显示当前时间：
char* ctime(const time_t* time);
该函数返回一个表示当地时间的字符串指针，输出内容格式如下：
day month year hours:minutes:seconds year\n\0。
示例代码：
void func() {
time_t now = time(NULL);
char* dt = ctime(&now);
cout << "cur time is: " << dt;
}
// 输出：Tue Sep 22 22:01:40 2020
可以使用 tm 结构自定义显示当前时间的格式：
struct tm * localtime(const time_t * timer);
将日历时间转换为本地时间，从 1970 年起始的时间戳转换为 1900 年起始的时间数据结构。
另一个类似的函数是 gmtime 函数：
struct tm *gmtime(const time_t *time);
只是该函数返回的是 UTC 时间。
tm 结构如下：
struct tm {
int tm_sec; // 秒，正常范围从 0 到 59，但允许至 61
int tm_min; // 分，范围从 0 到 59
int tm_hour; // 小时，范围从 0 到 23
int tm_mday; // 一月中的第几天，范围从 1 到 31
int tm_mon; // 月，范围从 0 到 11
int tm_year; // 自 1900 年起的年数
int tm_wday; // 一周中的第几天，范围从 0 到 6，从星期日算起
int tm_yday; // 一年中的第几天，范围从 0 到 365，从 1 月 1 日算起
int tm_isdst; // 夏令时
};
tm_sec 在 C89 的范围是 [0-61]，在 C99 更正为 [0-60]。通常范围是 [0-59]，有些系统会出现 60 秒的跳跃。
tm_mon 是从零开始的，所以一月份为 0，十二月份为 11。
tm_year 是从 1900 年开始计算，所以显示年份的时候需要加上 1900。
void func() {
time_t rawtime = time(NULL);
struct tm* ptminfo = localtime(&rawtime);
printf("cur time is: %02d-%02d-%02d %02d:%02d:%02d\n", ptminfo->tm_year + 1900, ptminfo->tm_mon + 1, ptminfo->tm_mday, ptminfo->tm_hour, ptminfo->tm_min, ptminfo->tm_sec);
ptminfo = gmtime(&rawtime);
printf("cur time is: %02d-%02d-%02d %02d:%02d:%02d\n", ptminfo->tm_year + 1900, ptminfo->tm_mon + 1, ptminfo->tm_mday, ptminfo->tm_hour, ptminfo->tm_min, ptminfo->tm_sec);
}
// 输出：
// cur time is: 2020-09-23 21:27:37
// cur time is: 2020-09-23 13:27:37
可以通过 asctime 显示 tm 结构的时间：
char * asctime ( const struct tm * time );
和 ctime 类似，返回的都是一个固定时间格式的字符串，只是传入的参数不同。
void func() {
time_t rawtime = time(NULL);
struct tm* info1 = localtime(&rawtime);
cout << "正常 日期和时间：" << asctime(info1) << endl;
info1 = gmtime(&rawtime);
cout << "UTC 日期和时间：" << asctime(info1) << endl;
}
// 输出：
// 正常 日期和时间：Wed Sep 23 21:47:44 2020
// UTC 日期和时间：Wed Sep 23 13:47:44 2020
也可以使用 strftime() 函数，该函数可用于格式化日期和时间为指定的格式，如果产生的 C 字符串小于 size 个字符（包括空结束字符），则会返回复制到 str 中的字符总数（不包括空结束字符），否则返回零。
size_t strftime(
char *str, // 指向目标数组的指针，用来复制产生的 C 字符串
size_t maxsize,// 最多传出字符数量
const char *format,// 格式化方式
const struct tm *timeptr// tm指针
);
format 格式如下：
%a 星期几的缩写
%A 星期几的全称
%b 月份的缩写
%B 月份的全称
%c 标准的日期的时间串
%C 年份的前两位数字
%d 十进制表示的每月的第几天（值从1到31）
%D 月/天/年
%e 在两字符域中，十进制表示的每月的第几天
%f 微秒
%F 年-月-日
%g 年份的后两位数字，使用基于周的年
%G 年份，使用基于周的年
%h 简写的月份名
%H 24小时制的小时（值从0到23）
%I 12小时制的小时（值从1到12）
%j 十进制表示的每年的第几天（值从1到366）
%m 十进制表示的月份（值从1到12）
%M 十时制表示的分钟数（值从0到59）
%n 换行符
%p 本地的AM或PM的等价显示
%r 12小时的时间
%R 显示小时和分钟：hh:mm
%S 十进制的秒数（值从0到61）
%t 水平制表符
%T 显示时分秒：hh:mm:ss
%u 每周的第几天，星期一为第一天（值从1到7，星期一为1）
%U 第年的第几周，把星期日作为第一天（值从0到53）
%V 每年的第几周，使用基于周的年
%w 十进制表示的星期几（值从0到6，星期天为0）
%W 每年的第几周，把星期一做为第一天（值从0到53）
%x 标准的日期串
%X 标准的时间串
%y 不带世纪的十进制年份（值从0到99）
%Y 带世纪部分的十进制年份
%Z 时区名称，如果不能得到时区名称则返回空字符。
%% 一个%符号
使用代码如下：
void func() {
time_t rawtime = time(NULL);
char buf[256];
strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", localtime(&rawtime));
cout << buf << endl;
}
参考资料：
- https://www.runoob.com/cprogramming/c-function-strftime.html
- https://www.runoob.com/cprogramming/c-function-clock.html
- https://www.runoob.com/cplusplus/cpp-date-time.html
- https://www.cnblogs.com/jwk000/p/3560086.html
总结 #
C++提供了两种处理时间的方式：
- 现代的chrono库，提供类型安全和高精度的时间处理功能
- 传统的C风格API，提供基础的时间处理功能
在实际开发中，建议：
- 优先使用chrono库，特别是在需要高精度计时的场景
- 对于简单的时间获取和格式化，C风格API也是可接受的选择
- 性能计时优先使用steady_clock，避免系统时间调整带来的影响