如何在C++中获取系统时间戳_C++时间戳获取与转换

裘德小鎮的故事

发布时间：2025-09-19 13:27:01

988人浏览过

来源于php中文网

原创

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++时间戳获取与转换

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

是现代C++处理时间的首选，因为它提供了类型安全和更高的精度。要获取高精度时间戳，我们主要依赖

std::chrono::system_clock

。

Magic Write

Canva旗下AI文案生成器

下载

system_clock::now()

返回的是一个

time_point

对象，它代表了时间轴上的一个特定时刻。这个

time_point

内部其实是存储了自

system_clock

的epoch（通常是Unix Epoch）以来的一个

duration

（时间间隔）。

要获取具体的时间戳值，我们需要将这个

duration

转换为我们想要的精度单位（比如毫秒、微秒、纳秒），然后获取其计数值。

#include 
#include 
#include  // For std::put_time

void 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_time

void 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::istringstream

void 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
```
  ），但这样做会牺牲