C++中推荐使用std::chrono获取时间戳，它提供高精度、类型安全的现代方法；通过system_clock::now()获取当前时间点，再用duration_cast转换为秒、毫秒等整数时间戳。对于可读格式转换，需结合ctime库的to_time_t和localtime/gmtime，再用put_time或strftime格式化；反向解析则用get_time、mktime和from_time_t。多线程下应避免localtime非线程安全问题，改用localtime_r或C++20时区功能；测量间隔应使用steady_clock以保证单调性。
C++中获取系统时间戳，最现代且推荐的方式是使用C++11引入的
库，它提供了高精度、类型安全的时间处理能力。当然，对于一些老项目或特定兼容性需求，基于C语言的
库（如
time_t
和
struct tm
）也依然是常见的选择。
解决方案
在C++中，获取系统时间戳并进行转换，我们通常会围绕
std::chrono
和
std::ctime
两个库展开。
使用
std::chrono
(C++11及更高版本)
std::chrono::system_clock
是获取系统当前时间点的首选。它代表了“挂钟时间”，可以被用户或网络时间协议（NTP）调整。
立即学习“C++免费学习笔记（深入）”；
获取当前时间点:
std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
转换为时间戳（例如，自Epoch以来的毫秒数或秒数）:时间点本身不是一个直接的整数时间戳，我们需要将其转换为自Unix Epoch（1970年1月1日00:00:00 UTC）以来的时间间隔（duration），然后获取其计数。
#include #include #include // For std::time_t conversion later// 获取秒级时间戳long long timestamp_seconds = std::chrono::duration_cast( now.time_since_epoch()).count();// 获取毫秒级时间戳long long timestamp_milliseconds = std::chrono::duration_cast( now.time_since_epoch()).count();// 获取微秒级时间戳long long timestamp_microseconds = std::chrono::duration_cast( now.time_since_epoch()).count();// 获取纳秒级时间戳 (system_clock 的默认精度通常是微秒或纳秒，取决于系统)long long timestamp_nanoseconds = std::chrono::duration_cast( now.time_since_epoch()).count();std::cout << "秒级时间戳: " << timestamp_seconds << std::endl;std::cout << "毫秒级时间戳: " << timestamp_milliseconds << std::endl;std::cout << "微秒级时间戳: " << timestamp_microseconds << std::endl;std::cout << "纳秒级时间戳: " << timestamp_nanoseconds << std::endl;
使用
std::ctime
(C风格)
std::time_t
通常是一个整数类型，表示自Unix Epoch以来的秒数。
获取当前时间戳:
std::time_t now_c = std::time(nullptr);
std::time(nullptr)
返回当前日历时间，通常是自Epoch以来的秒数。
转换为可读格式 (例如，
struct tm
):
struct tm* local_time = std::localtime(&now_c);
// 本地时间
struct tm* gmt_time = std::gmtime(&now_c);
// UTC时间
std::localtime
和
std::gmtime
会将
time_t
转换为
struct tm
结构体，其中包含了年、月、日、时、分、秒等信息。需要注意的是，这两个函数返回的是指向静态存储区的指针，在多线程环境下使用时需要特别小心，或者使用其线程安全版本（如POSIX的
localtime_r
或Windows的
localtime_s
）。
从
struct tm
转换回
time_t
:
std::time_t re_converted_time = std::mktime(local_time);
std::mktime
将本地时间表示的
struct tm
结构体转换回
time_t
类型。
C++11及更高版本中，如何用
std::chrono
std::chrono
获取高精度时间戳？
在我看来，
std::chrono
是现代C++处理时间的首选，因为它提供了类型安全和更高的精度。要获取高精度时间戳，我们主要依赖
std::chrono::system_clock
。
system_clock::now()
返回的是一个
time_point
对象，它代表了时间轴上的一个特定时刻。这个
time_point
内部其实是存储了自
system_clock
的epoch（通常是Unix Epoch）以来的一个
duration
（时间间隔）。
要获取具体的时间戳值，我们需要将这个
duration
转换为我们想要的精度单位（比如毫秒、微秒、纳秒），然后获取其计数值。
#include #include #include // For std::put_timevoid print_high_res_timestamp() { auto now = std::chrono::system_clock::now(); // 获取纳秒级时间戳 auto nanoseconds_since_epoch = std::chrono::duration_cast( now.time_since_epoch() ).count(); std::cout << "当前纳秒级时间戳: " << nanoseconds_since_epoch << std::endl; // 获取毫秒级时间戳 auto milliseconds_since_epoch = std::chrono::duration_cast( now.time_since_epoch() ).count(); std::cout << "当前毫秒级时间戳: " << milliseconds_since_epoch << std::endl; // 获取秒级时间戳 auto seconds_since_epoch = std::chrono::duration_cast( now.time_since_epoch() ).count(); std::cout << "当前秒级时间戳: " << seconds_since_epoch << std::endl; // 顺便提一下：system_clock 的精度可能不是真正的纳秒，但它会提供你能得到的最高精度 // 比如在某些系统上，它的最小刻度可能是微秒。duration_cast 会帮你处理精度转换。 // 如果你需要测量代码执行时间，而不是系统挂钟时间，你应该考虑使用 std::chrono::steady_clock。 // steady_clock 是单调递增的，不受系统时间调整的影响，非常适合计时。 // 比如： // auto start = std::chrono::steady_clock::now(); // // ... 执行一些操作 ... // auto end = std::chrono::steady_clock::now(); // auto elapsed_ms = std::chrono::duration_cast(end - start).count(); // std::cout << "操作耗时: " << elapsed_ms << " 毫秒" << std::endl;}// 调用示例// print_high_res_timestamp();
std::chrono::system_clock
的实际精度取决于操作系统和硬件。
duration_cast
在进行转换时，如果目标精度低于源精度，会进行截断；如果目标精度高于源精度，则不会增加实际的有效位数。选择合适的
duration_cast
单位非常重要，它决定了你最终时间戳的粒度。
如何将C++时间戳转换为可读的日期时间字符串，或反向转换？
将时间戳转换为人类可读的日期时间字符串，以及反向操作，是时间处理中非常常见的需求。
std::chrono
本身不直接提供格式化功能，它通常需要结合C风格的
库来完成。
时间戳转换为日期时间字符串
这里我们以
std::chrono::system_clock::time_point
为例。
将
time_point
转换为
std::time_t
:这是连接
std::chrono
和
std::ctime
的关键一步。
std::chrono::system_clock::to_time_t
函数可以完成这个转换。
将
std::time_t
转换为
struct tm
:使用
std::localtime
（本地时间）或
std::gmtime
（UTC时间）。
使用
std::put_time
或
std::strftime
格式化
struct tm
:
std::put_time
(C++11) 是一个I/O操纵器，可以方便地与
std::cout
一起使用。
std::strftime
是C风格的函数，提供更细粒度的控制。
#include #include #include #include // For std::put_timevoid timestamp_to_string_example() { auto now_tp = std::chrono::system_clock::now(); // 1. 转换为 std::time_t std::time_t now_c = std::chrono::system_clock::to_time_t(now_tp); // 2. 转换为 struct tm (这里使用本地时间) // 注意：localtime 返回的指针指向静态存储区，非线程安全。 // 在多线程环境应使用 localtime_r (POSIX) 或 localtime_s (Windows) std::tm* local_tm = std::localtime(&now_c); if (local_tm) { // 3. 使用 std::put_time 格式化输出 std::cout << "当前本地时间 (YYYY-MM-DD HH:MM:SS): " << std::put_time(local_tm, "%Y-%m-%d %H:%M:%S") << std::endl; // 也可以格式化为其他形式，比如带星期几 std::cout << "当前本地时间 (Full): " << std::put_time(local_tm, "%A, %B %d, %Y %H:%M:%S") << std::endl; } else { std::cerr << "无法获取本地时间信息。" << std::endl; } // 如果想获取UTC时间 std::tm* gmt_tm = std::gmtime(&now_c); if (gmt_tm) { std::cout << "当前UTC时间 (YYYY-MM-DD HH:MM:SS): " << std::put_time(gmt_tm, "%Y-%m-%d %H:%M:%S") << std::endl; }}// 调用示例// timestamp_to_string_example();
日期时间字符串转换为时间戳
这个过程相对复杂一些，因为涉及到字符串解析。
使用
std::get_time
或手动解析字符串为
struct tm
:
std::get_time
(C++11) 是
std::put_time
的反向操作，可以从输入流中解析日期时间字符串并填充
struct tm
。
将
struct tm
转换为
std::time_t
:使用
std::mktime
。
将
std::time_t
转换为
std::chrono::system_clock::time_point
:使用
std::chrono::system_clock::from_time_t
。
#include #include #include #include #include // For std::istringstreamvoid string_to_timestamp_example() { std::string time_str = "2023-10-27 10:30:00"; std::tm t = {}; // 初始化为零 // 1. 使用 std::get_time 解析字符串到 struct tm std::istringstream ss(time_str); ss >> std::get_time(&t, "%Y-%m-%d %H:%M:%S"); if (ss.fail()) { std::cerr << "解析日期时间字符串失败: " << time_str << std::endl; return; } // 2. 将 struct tm 转换为 std::time_t // mktime 假定 t 是本地时间，并会根据本地时区调整 std::time_t time_c = std::mktime(&t); if (time_c == -1) { // mktime 失败会返回 -1 std::cerr << "mktime 转换失败。" << std::endl; return; } // 3. 将 std::time_t 转换为 std::chrono::system_clock::time_point auto time_point = std::chrono::system_clock::from_time_t(time_c); // 获取毫秒级时间戳并打印 long long timestamp_ms = std::chrono::duration_cast( time_point.time_since_epoch() ).count(); std::cout << "字符串 "" << time_str << "" 转换为毫秒级时间戳: " << timestamp_ms << std::endl; // 验证：再转回字符串看看 std::time_t check_c = std::chrono::system_clock::to_time_t(time_point); std::tm* check_tm = std::localtime(&check_c); if (check_tm) { std::cout << "验证转换回字符串: " << std::put_time(check_tm, "%Y-%m-%d %H:%M:%S") << std::endl; }}// 调用示例// string_to_timestamp_example();
需要注意的是，
std::get_time
和
std::put_time
对时区的处理相对简单，默认是本地时区。如果需要处理更复杂的时区转换或国际化日期格式，可能需要考虑使用第三方库，例如Howard Hinnant的
date
库（C++20中部分功能已被纳入标准库）。
在多线程或性能敏感场景下，C++时间戳获取有什么需要注意的？
在开发高性能或并发应用时，时间戳的获取和处理确实有一些细节需要特别关注。这不仅仅是关于代码是否能跑起来，更是关于它的正确性、效率和稳定性。
std::chrono::system_clock
的非单调性与
std::chrono::steady_clock
system_clock
反映的是系统“挂钟”时间，它可能会因为NTP同步、用户手动调整或夏令时等原因向前或向后跳变。这意味着，如果你用
system_clock
来测量两个事件之间的时间间隔，结果可能是不准确的，甚至可能是负数。例如，你记录一个开始时间，系统时钟突然被NTP调慢了，那么结束时间可能会比开始时间还“早”。解决方案： 当你需要测量时间间隔（比如函数执行耗时、两个事件的间隔），务必使用
std::chrono::steady_clock
。
steady_clock
保证是单调递增的，不受系统时钟调整的影响，是测量持续时间的理想选择。
// 测量代码块执行时间auto start = std::chrono::steady_clock::now();// ... 你的代码逻辑 ...auto end = std::chrono::steady_clock::now();auto duration = std::chrono::duration_cast(end - start);std::cout << "代码执行耗时: " << duration.count() << " 微秒" << std::endl;
C风格时间函数 (
localtime
,
gmtime
) 的线程安全性前面也提到过，
std::localtime
和
std::gmtime
函数返回的是指向静态内部缓冲区的指针 (
struct tm*
)。这意味着在多线程环境中，如果多个线程同时调用这些函数，它们可能会互相覆盖对方的数据，导致不可预测的行为和数据竞争。这是一个非常常见的陷阱。解决方案：
POSIX系统 (Linux/macOS): 使用线程安全版本
localtime_r
和
gmtime_r
。它们接受一个
struct tm
指针作为参数，将结果写入用户提供的缓冲区。
std::time_t now_c = std::time(nullptr);std::tm local_tm_buf; // 用户提供的缓冲区localtime_r(&now_c, &local_tm_buf); // 线程安全// 现在可以使用 local_tm_buf 了
Windows系统: 使用
localtime_s
和
gmtime_s
。它们也是线程安全的，并且有额外的安全检查。
std::time_t now_c = std::time(nullptr);std::tm local_tm_buf;localtime_s(&local_tm_buf, &now_c); // 线程安全// 现在可以使用 local_tm_buf 了
C++20 解决方案: C++20 引入了
库对时区的支持，提供了更现代、线程安全且功能丰富的日期时间处理方式，例如
std::chrono::zoned_time
和
std::chrono::local_time
，可以避免这些C风格函数的陷阱。
时间戳获取的开销通常来说，获取当前时间戳（无论是
system_clock::now()
还是
time(nullptr)
）的开销都非常小，在绝大多数应用中可以忽略不计。然而，在极度性能敏感的紧密循环中，如果每毫秒都需要获取数百次时间戳，那么即使是微小的开销也可能累积。解决方案：
减少不必要的获取： 问问自己是否真的需要那么频繁地获取时间戳。缓存： 如果时间戳在短时间内不需要绝对的实时性，可以考虑每隔一段时间（例如10ms或100ms）获取一次，然后缓存起来供多次使用。特定硬件/OS API： 在某些极端高性能场景，开发者可能会直接调用操作系统提供的底层高精度计时器API（如Windows上的
QueryPerformanceCounter
，Linux上的
clock_gettime
），但这样做会牺牲
以上就是如何在C++中获取系统时间戳_C++时间戳获取与转换的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1476077.html
微信扫一扫 
支付宝扫一扫 
