如何在C++中获取当前日期和时间_C++日期时间库使用详解-C++-PHP中文网

使用<chrono>库获取当前时间，通过std::chrono::system_clock::now()得到时间点，转换为std::time_t后用std::localtime或std::gmtime转为std::tm结构，再结合std::put_time格式化输出；推荐std::put_time进行安全、现代的流式格式化，而时区处理在C++20前建议统一使用UTC时间并借助std::gmtime，复杂场景可引入第三方库如Howard Hinnant的date库；日期时间计算利用duration与time_point支持加减和比较操作，实现高精度且类型安全的时间间隔测量与逻辑判断。

如何在c++中获取当前日期和时间_c++日期时间库使用详解

在C++中获取当前日期和时间，通常我们会依赖两个核心库：现代C++推崇的

<chrono>

登录后复制

库（C++11及更高版本），以及传统的C风格

<ctime>

登录后复制

库。如果你追求类型安全、高精度和更现代的编程范式，

<chrono>

登录后复制

无疑是首选；而

<ctime>

登录后复制

则在兼容旧代码或简单场景下仍有其用武之地。

解决方案

要获取当前日期和时间，最直接的方法是利用

std::chrono::system_clock::now()

登录后复制

。这会返回一个

time_point

登录后复制

对象，代表了自系统时钟纪元（epoch）以来经过的时间。这个

time_point

登录后复制

本身并不直接提供人类可读的日期时间格式，它更像是一个时间戳。为了将其转化为我们熟悉的年、月、日、时、分、秒，我们需要一些转换步骤。

一个常见的流程是将

std::chrono::system_clock::now()

登录后复制

得到的

time_point

登录后复制

转换为

std::time_t

登录后复制

类型。

std::time_t

登录后复制

是一个算术类型，通常表示自UTC时间1970年1月1日00:00:00以来经过的秒数。一旦有了

std::time_t

登录后复制

，我们就可以使用C标准库中的

std::localtime

登录后复制

（获取本地时间）或

std::gmtime

登录后复制

（获取UTC时间）将其转换为

std::tm

登录后复制

结构体。

std::tm

登录后复制

结构体包含了年、月、日、时、分、秒等成员，方便我们进行格式化输出。

#include <iostream>
#include <chrono>
#include <ctime>   // for std::time_t, std::tm, std::localtime, std::mktime, std::put_time

int main() {
    // 1. 获取当前时间点
    auto now = std::chrono::system_clock::now();

    // 2. 将时间点转换为std::time_t
    // 注意：system_clock的time_point可以直接转换为time_t
    std::time_t now_c = std::chrono::system_clock::to_time_t(now);

    // 3. 将std::time_t转换为本地时间结构体std::tm
    // std::localtime返回的指针指向一个静态分配的tm对象，非线程安全
    // 更好的做法是使用可重入版本，如localtime_r (POSIX) 或手动复制
    // 这里为演示目的，简化处理
    std::tm* local_tm = std::localtime(&now_c);

    // 4. 使用std::put_time进行格式化输出 (C++11)
    if (local_tm) { // 检查指针是否有效
        std::cout << "当前本地日期和时间 (C++11 chrono + put_time): ";
        std::cout << std::put_time(local_tm, "%Y-%m-%d %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日期和时间 (C++11 chrono + put_time): ";
        std::cout << std::put_time(gmt_tm, "%Y-%m-%d %H:%M:%S UTC") << std::endl;
    } else {
        std::cerr << "获取UTC时间失败。" << std::endl;
    }

    // 传统C风格的ctime库用法（仅作对比，不推荐新项目使用）
    // std::time_t rawtime;
    // std::time(&rawtime); // 获取当前时间戳
    // std::tm* info = std::localtime(&rawtime); // 转换为本地时间结构体
    // char buffer[80];
    // std::strftime(buffer, sizeof(buffer), "%Y-%m-%d %H:%M:%S", info);
    // std::cout << "当前本地日期和时间 (C风格 ctime): " << buffer << std::endl;

    return 0;
}

登录后复制

这段代码展示了如何利用

<chrono>

登录后复制

获取时间点，再通过

<ctime>

登录后复制

的工具链将其格式化。值得注意的是，

std::localtime

登录后复制

和

std::gmtime

登录后复制

是非线程安全的，它们返回的指针指向一个内部静态缓冲区。在多线程环境中，你需要考虑使用它们的线程安全版本（如POSIX的

localtime_r

登录后复制

）或自行复制

std::tm

登录后复制

结构体。

立即学习“C++免费学习笔记（深入）”；

如何精确控制日期时间的格式化输出？

对日期时间进行格式化输出是日常开发中一个非常普遍的需求。C++标准库主要提供了两种方式来精细控制输出格式：

std::put_time

登录后复制

（C++11及更高版本）和

std::strftime

登录后复制

（C风格）。两者都依赖于

std::tm

登录后复制

结构体，并使用一套类似的格式化指令（format specifiers）。

std::put_time

登录后复制

是

<iomanip>

登录后复制

头文件中的一个流操纵符，它与

std::cout

登录后复制

结合使用，能够将

std::tm

登录后复制

对象按照指定的格式输出。它的优势在于与C++的I/O流系统无缝集成，使用起来更符合现代C++的风格。而

std::strftime

登录后复制

则是一个C函数，它将格式化后的字符串写入一个字符缓冲区，需要手动管理缓冲区大小，但其灵活性和广泛支持使其在某些场景下仍然有用。

以下是一些常用的格式化指令：

```
%Y
```
登录后复制
: 四位数的年份（例如：2023）
```
%m
```
登录后复制
: 两位数的月份（01-12）
```
%d
```
登录后复制
: 两位数的日期（01-31）
```
%H
```
登录后复制
: 24小时制的小时（00-23）
```
%m
```
登录后复制
: 两位数的分钟（00-59）
```
%S
```
登录后复制
: 两位数的秒（00-59）
```
%w
```
登录后复制
: 星期几（0-6，星期日为0）
```
%a
```
登录后复制
: 缩写星期名称（例如：Mon）
```
%a
```
登录后复制
: 完整星期名称（例如：Monday）
```
%b
```
登录后复制
: 缩写月份名称（例如：Jan）
```
%b
```
登录后复制
: 完整月份名称（例如：January）
```
%c
```
登录后复制
: 本地日期和时间表示（例如：Mon Jan 1 12:34:56 2023）
```
%x
```
登录后复制
: 本地日期表示
```
%x
```
登录后复制
: 本地时间表示

例如，如果你想输出"YYYY年MM月DD日 HH时MM分SS秒"，你可以这样做：

#include <iostream>
#include <chrono>
#include <ctime>
#include <iomanip> // for std::put_time

int main() {
    auto now = std::chrono::system_clock::now();
    std::time_t now_c = std::chrono::system_clock::to_time_t(now);
    std::tm* local_tm = std::localtime(&now_c);

    if (local_tm) {
        // 使用put_time进行多种格式化输出
        std::cout << "格式1 (YYYY-MM-DD HH:MM:SS): "
                  << std::put_time(local_tm, "%Y-%m-%d %H:%M:%S") << std::endl;

        std::cout << "格式2 (MM/DD/YY hh:mm AM/PM): "
                  << std::put_time(local_tm, "%m/%d/%y %I:%M %p") << std::endl;

        std::cout << "格式3 (完整日期时间，包含星期): "
                  << std::put_time(local_tm, "%A, %B %d, %Y %H:%M:%S") << std::endl;

        // 使用strftime (需要缓冲区)
        char buffer[100];
        if (std::strftime(buffer, sizeof(buffer), "今天是 %Y年%m月%d日，现在是 %H时%M分%S秒", local_tm)) {
            std::cout << "strftime输出: " << buffer << std::endl;
        } else {
            std::cerr << "strftime格式化失败。" << std::endl;
        }
    }
    return 0;
}

登录后复制

选择

std::put_time

登录后复制

还是

std::strftime

登录后复制

，主要取决于你的项目需求和C++版本。在现代C++项目中，

std::put_time

登录后复制

通常是更推荐的选择，因为它更安全、更易用，并且与C++的I/O流机制更协调。

处理时区和UTC时间有什么最佳实践？

在处理日期和时间时，时区是一个绕不开的复杂问题。不同地区有不同的本地时间，而UTC（Coordinated Universal Time，协调世界时）则提供了一个全球统一的时间基准，不随地理位置或季节变化。在跨区域、分布式系统或需要精确时间同步的场景中，使用UTC时间作为内部存储和传输的标准是最佳实践。

美间AI

美间AI：让设计更简单

查看详情

C++标准库在C++20之前对时区的原生支持是比较有限的，主要通过

std::gmtime

登录后复制

（获取UTC时间对应的

std::tm

登录后复制

结构）和

std::localtime

登录后复制

（获取本地时间对应的

std::tm

登录后复制

结构）来区分。

std::gmtime

登录后复制

会将

std::time_t

登录后复制

（通常被认为是UTC时间戳）转换为UTC时区的

std::tm

登录后复制

结构，而

std::localtime

登录后复制

则会根据系统设置的时区进行转换。

要获取当前的UTC时间，你可以直接将

std::chrono::system_clock::now()

登录后复制

转换为

std::time_t

登录后复制

，然后使用

std::gmtime

登录后复制

。

#include <iostream>
#include <chrono>
#include <ctime>
#include <iomanip>

int main() {
    auto now = std::chrono::system_clock::now();
    std::time_t now_c = std::chrono::system_clock::to_time_t(now);

    // 获取UTC时间
    std::tm* gmt_tm = std::gmtime(&now_c);
    if (gmt_tm) {
        std::cout << "当前UTC时间: " << std::put_time(gmt_tm, "%Y-%m-%d %H:%M:%S UTC") << std::endl;
    } else {
        std::cerr << "获取UTC时间失败。" << std::endl;
    }

    // 获取本地时间
    std::tm* local_tm = std::localtime(&now_c);
    if (local_tm) {
        std::cout << "当前本地时间: " << std::put_time(local_tm, "%Y-%m-%d %H:%M:%S %Z") << std::endl;
        // %Z 可以尝试输出时区名称，但其支持依赖于具体实现和系统设置
    } else {
        std::cerr << "获取本地时间失败。" << std::endl;
    }

    return 0;
}

登录后复制

在C++20中，

<chrono>

登录后复制

库得到了显著增强，引入了

std::chrono::utc_clock

登录后复制

、

std::chrono::tai_clock

登录后复制

以及更完善的时区支持。如果你使用的是C++20或更新的标准，可以直接使用

std::chrono::utc_clock::now()

登录后复制

来获取UTC时间点，并且有专门的

zoned_time

登录后复制

和

time_zone

登录后复制

类来处理时区转换。这大大简化了时区处理的复杂性，并提供了更类型安全的解决方案。

对于C++17及更早的版本，如果需要更复杂的时区处理（例如，跨时区转换、夏令时规则），你可能需要考虑使用第三方库，例如Howard Hinnant的

date

登录后复制

库（该库的许多特性已被C++20

<chrono>

登录后复制

采纳），或者Boost.DateTime库。这些库提供了更强大、更全面的时区管理功能，能够应对各种复杂的时区场景。

日期时间计算和比较有哪些常见场景和技巧？

日期和时间的计算与比较是另一个高频需求，例如计算事件持续时间、判断某个时间点是否在特定区间内、或者在当前时间基础上增加/减少一段时间。C++的

<chrono>

登录后复制

库在这方面表现出色，它提供了

duration

登录后复制

（时长）和

time_point

登录后复制

（时间点）的概念，使得日期时间计算变得类型安全且直观。

std::chrono::duration

登录后复制

用于表示一段时间的长度，可以精确到纳秒、微秒、毫秒、秒、分钟、小时等。它由一个计数器类型和一个周期类型组成，例如

std::chrono::seconds

登录后复制

、

std::chrono::milliseconds

登录后复制

。

std::chrono::time_point

登录后复制

则表示时间轴上的一个特定点，它通常由一个时钟（如

system_clock

登录后复制

）和一个

duration

登录后复制

组成，表示自时钟纪元以来的时长。

1. 计算时间间隔（Duration）： 你可以通过两个

time_point

登录后复制

相减来获得它们之间的时间间隔，结果是一个

duration

登录后复制

对象。

#include <iostream>
#include <chrono>
#include <thread> // for std::this_thread::sleep_for

int main() {
    auto start = std::chrono::high_resolution_clock::now(); // 更高精度时钟

    // 模拟一些工作
    std::this_thread::sleep_for(std::chrono::milliseconds(1234));

    auto end = std::chrono::high_resolution_clock::now();

    // 计算持续时间
    auto duration = end - start;

    // 将持续时间转换为不同的单位
    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
    auto s = std::chrono::duration_cast<std::chrono::seconds>(duration).count();

    std::cout << "操作耗时: " << ms << " 毫秒" << std::endl;
    std::cout << "操作耗时: " << s << " 秒" << std::endl; // 会向下取整

    // 也可以直接输出 duration 对象 (C++20)
    // std::cout << "精确耗时: " << duration << std::endl;
    // 对于C++17及之前，需要手动格式化
    std::cout << "精确耗时 (微秒): " << std::chrono::duration_cast<std::chrono::microseconds>(duration).count() << " 微秒" << std::endl;

    return 0;
}

登录后复制

2. 日期时间加减（Adding/Subtracting Durations）：

time_point

登录后复制

可以与

duration

登录后复制

进行加减运算，从而得到一个新的

time_point

登录后复制

。

#include <iostream>
#include <chrono>
#include <ctime>
#include <iomanip>

int main() {
    auto now = std::chrono::system_clock::now();
    std::time_t now_c = std::chrono::system_clock::to_time_t(now);
    std::tm* local_tm = std::localtime(&now_c);

    if (local_tm) {
        std::cout << "当前时间: " << std::put_time(local_tm, "%Y-%m-%d %H:%M:%S") << std::endl;
    }

    // 在当前时间基础上增加1小时30分钟
    auto future_time = now + std::chrono::hours(1) + std::chrono::minutes(30);
    std::time_t future_c = std::chrono::system_clock::to_time_t(future_time);
    std::tm* future_tm = std::localtime(&future_c);

    if (future_tm) {
        std::cout << "1小时30分钟后: " << std::put_time(future_tm, "%Y-%m-%d %H:%M:%S") << std::endl;
    }

    // 减少2天
    auto past_time = now - std::chrono::days(2); // C++20 才有 std::chrono::days
    // 对于C++17及之前，需要转换为小时或秒：
    // auto past_time = now - std::chrono::hours(2 * 24);
    std::time_t past_c = std::chrono::system_clock::to_time_t(past_time);
    std::tm* past_tm = std::localtime(&past_c);

    if (past_tm) {
        std::cout << "2天前: " << std::put_time(past_tm, "%Y-%m-%d %H:%M:%S") << std::endl;
    }

    return 0;
}

登录后复制

注意：

std::chrono::days

登录后复制

、

std::chrono::weeks

登录后复制

等单位是在C++20中引入的。在C++17及以前，你需要将天数转换为小时或秒（例如，

2 * 24 * std::chrono::hours(1)

登录后复制

或

2 * 24 * 60 * 60 * std::chrono::seconds(1)

登录后复制

）。

3. 日期时间比较：

time_point

登录后复制

对象可以直接进行比较操作，如

==

登录后复制

!=

登录后复制

<=

登录后复制

>=

登录后复制

。这使得判断时间顺序或检查时间点是否在某个区间内变得非常简单。

#include <iostream>
#include <chrono>
#include <thread>

int main() {
    auto time1 = std::chrono::system_clock::now();
    std::this_thread::sleep_for(std::chrono::seconds(1));
    auto time2 = std::chrono::system_clock::now();
    std::this_thread::sleep_for(std::chrono::seconds(1));
    auto time3 = std::chrono::system_clock::now();

    if (time1 < time2) {
        std::cout << "time1 在 time2 之前" << std::endl;
    }

    if (time2 == time2) { // 显然
        std::cout << "time2 等于 time2" << std::endl;
    }

    if (time3 > time1) {
        std::cout << "time3 在 time1 之后" << std::endl;
    }

    // 判断某个时间点是否在特定区间内
    auto specific_point = time1 + std::chrono::milliseconds(500);
    if (specific_point > time1 && specific_point < time2) {
        std::cout << "特定时间点在 time1 和 time2 之间" << std::endl;
    }

    return 0;
}

登录后复制

通过这些