C++中std::chrono时间库的全面解析

一、引言

C++ std::chrono时间库是C++标准库提供的一个时间处理库，提供了一个方便、灵活和精确的时间处理工具，用于在程序中进行时间相关的操作和计算。它具有以下重要性和作用：

精确的时间计量：std::chrono时间库提供了高精度的时间计量单位和操作，可以精确测量和计算代码的执行时间、延时等。

跨平台兼容性：std::chrono时间库在不同平台上都具备良好的兼容性，无论是Windows、Linux还是其他操作系统，都可以使用该库进行时间处理，使代码具备良好的可移植性。

高度可扩展性：该库提供了丰富的时间单位和精度选项，适应不同场景下的时间计算需求。无论是秒、毫秒、微秒还是纳秒的时间单位，都可以很方便地应用于代码中。

时钟的灵活选择：std::chrono时间库提供了不同类型的时钟，如系统时钟（system_clock）、稳定时钟（steady_clock）和高分辨率时钟（high_resolution_clock），可以根据具体需求选择合适的时钟类型。

时间点和时间段的处理：该库提供了表示时间点（time_point）和时间段（duration）的相关类，可以对时间进行精确刻度和处理。时间点表示具体的时间，时间段表示两个时间点之间的时间差。

C++ std::chrono时间库能够帮助准确测量和控制代码的执行时间，处理定时任务，进行时间间隔计算等操作。这里将全面介绍C++ std::chrono时间库的使用，帮助读者理解其核心概念和各种功能，从而在编程中更好地掌握时间的节奏，解放代码从时间束缚中。

目标：

• 首先对C++ std::chrono时间库进行全面而清晰的概述，解释其在编程中的重要性和作用。
• 详细讲解C++ std::chrono时间库的组成部分，包括duration、time_point和clock。了解它们是如何相互配合工作的，以及如何使用它们来进行时间相关的操作。
• 供详细的使用攻略，涵盖duration（时间段）的使用方法、单位和精度的选择、示例代码等；time_point（时间点）的创建、比较和操作方法，以及相关的应用场景；不同类型的时钟（clock）的特点、适用场景和使用方法等。
• 除了基本的使用方法，还将探讨一些高级技巧和实践，如时区处理、时间格式转换等。我们还将解决一些常见的时间相关问题，提供实用的技巧和最佳实践，更高效、准确地使用时间库，解放代码从时间束缚中。

二、C++ std::chrono时间库概述

2.1、std::chrono命名空间的作用和用途

C++ std::chrono命名空间是C++标准库中的一个命名空间，它包含了一组用于处理时间和时间相关操作的类和函数。该命名空间提供了丰富的时间处理功能，旨在方便进行时间计算、测量和控制。

std::chrono命名空间的主要作用和用途：

1.提供时间单位和精度的定义：std::chrono命名空间定义了一系列时间单位，如秒（seconds）、毫秒（milliseconds）、微秒（microseconds）和纳秒（nanoseconds），以及精度等级，如高精度时钟（high_resolution_clock）和稳定时钟（steady_clock）。这些定义使得时间计算和测量更加灵活和精确。

2.定义时间段和时间点的概念：std::chrono命名空间提供了表示时间段（duration）和时间点（time_point）的相关类，包括std::chrono::duration和std::chrono::time_point。时间段表示两个时间点之间的时间差，时间点表示具体的时间。

3.支持时间的计算和操作：该命名空间提供了各种用于时间计算和操作的函数和操作符。例如，可以通过相加或相减两个时间点或时间段来计算时间的差异、延迟或间隔。也可以比较两个时间点的先后顺序，判断时间的先后关系。

4.管理和控制时间流逝：std::chrono命名空间提供了函数和工具，可用于管理和控制时间的流逝。例如，可以获取当前的系统时间和时钟时间，或者获取程序执行的实际时间。还可以设置定时任务或者延时执行代码。

5.std::chrono命名空间是C++标准库的一部分，因此它具有跨平台的兼容性，并且在不同的操作系统中都能正常工作。

2.2、基本组成部分：duration、time_point和clock

时间库的基本组成部分包括duration（时间段）、time_point（时间点）和clock（时钟）。它们相互配合，用于表示和处理时间的不同方面。

duration（时间段）：

duration是时间库中表示时间段的类。它表示两个时间点之间的时间差。时间段可以用秒（seconds）、毫秒（milliseconds）、微秒（microseconds）等不同的单位来表示。duration类的模板参数包括时间单位和所需的精度。比如：std::chrono::duration<int, std::ratio<1, 1000>>表示毫秒级别的时间段。在使用Duration时，可以进行加减、比较和表示等操作。

time_point（时间点）：

time_point表示一个特定的时间点，可以理解为时间的戳记。时间点和时间段之间可以进行加减运算，用于计算时间的差异或延迟。time_point类的模板参数包括所采用的时钟类型和时间单位。比如：std::chrono::time_point<std::chrono::system_clock, std::chrono::nanoseconds>表示系统时钟下的纳秒级时间点。可以获取当前的时间点、比较不同时间点的顺序，以及对时间点进行格式化等操作。

clock（时钟）：

clock是时间库中的时钟类，用于提供时间的基准和计量。不同的时钟类型提供不同的时间精度和功能。常用的时钟类型有系统时钟（system_clock）、稳定时钟（steady_clock）和高精度时钟（high_resolution_clock）。系统时钟提供了与操作系统相关的时间，稳定时钟提供了稳定的、不受系统时间变化影响的时间，而高精度时钟提供了更高的时间精度。时钟类可以获取当前时间，计算时间的间隔和延迟等。

这三个基本组成部分相互配合，使时间库具有了强大的时间处理能力。Duration表示时间段，Time_point表示时间点，而Clock则提供了时钟的基准。通过使用它们，可以对时间进行准确的计算、比较和操作，从而灵活地处理时间相关的任务和逻辑。

三、duration的使用详解

3.1、duration表示时间段的概念和使用方法

Duration（时间段）是时间库中表示时间间隔的类，用于表示两个时间点之间的时间差。

1.表示和定义duration:

duration类是一个模板类，模板参数包括时间单位和精度。时间单位可以是秒（seconds）、毫秒（milliseconds）、微秒（microseconds）或纳秒（nanoseconds），精度可以是整数类型（int、long）、浮点类型（float、double）等。例如，可以定义一个表示毫秒级别的时间段：std::chrono::duration<int, std::milli>。

2.创建duration对象:

可以通过直接给Duration对象赋值来创建它。对Duration对象的赋值可以使用整数、浮点数、其他duration对象，以及乘法、除法、加法和减法等操作。例如：

std::chrono::duration<int, std::milli> duration1(500); // 创建一个表示500毫秒的duration对象
std::chrono::duration<double, std::ratio<1, 1000>> duration2 = 2.5; // 创建一个表示2.5毫秒的duration对象
std::chrono::duration<float, std::ratio<1>> duration3 = duration1 + duration2; // 创建一个表示3秒的duration对象

3.访问duration的值:

可以使用成员函数count()来访问Duration对象的值。count()函数返回Duration对象表示的时间段值，以它所定义的时间单位返回。例如：

std::chrono::duration<int, std::milli> duration(500);
int milliseconds = duration.count(); // 返回500

4.操作duration:

可以使用各种数学运算符对duration对象进行加法、减法、乘法和除法等操作。这些操作在逻辑上保持了时间单位的一致性。例如：

std::chrono::duration<int, std::milli> duration1(500);
std::chrono::duration<double, std::nano> duration2(1.5);
std::chrono::duration<int, std::micro> duration3 = duration1 + duration2; // 表示501.5微秒
std::chrono::duration<int, std::milli> duration4 = duration1 * 2; // 表示1000毫秒
std::chrono::duration<double, std::milli> duration5 = duration2 / 2; // 表示0.75毫秒

5.比较duration:

可以使用比较运算符（<、<=、>、>=、==、!=）来比较duration对象之间的大小关系。比较操作是基于Duration对象所表示的时间单位进行的。例如：

std::chrono::duration<int, std::milli> duration1(500);
std::chrono::duration<double, std::nano> duration2(1.5);
bool result = duration1 > duration2; // 返回true，因为500毫秒大于1.5纳秒

3.2、duration的各种单位和精度选项

时间单位（Time Units）。时间单位表示Duration所表示时间间隔的度量单位。时间单位包括：

• 纳秒（nanoseconds）：std::chrono::nanoseconds
• 微秒（microseconds）：std::chrono::microseconds
• 毫秒（milliseconds）：std::chrono::milliseconds
• 秒（seconds）：std::chrono::seconds
• 分钟（minutes）：std::chrono::minutes
• 小时（hours）：std::chrono::hours

这些单位可以提供不同精度的时间间隔表示。

精度（Precision）:

精度表示duration所使用的数值类型，可以是整型（整数类型）或浮点型（浮点数类型）。可以使用标准数值类型（如int、long、float、double）作为Duration的数值类型，并与所选的时间单位进行配对。
例如，可以选择使用以下精度选项：

• 整数类型精度：std::chrono::duration<int, TimeUnit>
• 长整数类型精度：std::chrono::duration<long, TimeUnit>
• 浮点类型精度：std::chrono::duration<float, TimeUnit>
• 双精度类型精度：std::chrono::duration<double, TimeUnit>

例如，如果需要表示毫秒级别的时间间隔，可以选择std::chrono::duration<int, std::milli>，它使用整数类型表示毫秒。

下面是一些示例，展示了如何使用不同的时间单位和精度选项：

using namespace std::chrono;

// 表示10毫秒的duration，使用整数类型精度
duration<int, std::milli> duration1(10);

// 表示5秒的duration，使用长整数类型精度
duration<long, std::seconds> duration2(5);

// 表示2.5秒的duration，使用浮点类型精度
duration<float, std::seconds> duration3(2.5);

// 表示1分钟的duration，使用双精度类型精度
duration<double, std::minutes> duration4(1);

// 可以使用auto关键字自动推导出duration的类型
auto duration5 = duration<int, std::micro>(100);

3.3、使用示例

以下是一些使用Duration的具体示例，涵盖时间计算和延时操作：

时间计算示例：

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;

    // 创建两个时间点
    steady_clock::time_point start = steady_clock::now();
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟耗时操作
    steady_clock::time_point end = steady_clock::now();

    // 计算时间间隔
    duration<double> duration = duration_cast<duration<double>>(end - start);

    // 输出时间间隔
    std::cout << "Elapsed time: " << duration.count() << " seconds\n";

    return 0;
}

上述示例中，使用steady_clock来获取当前时间点，并通过duration_cast将时间间隔转换为秒。最后，使用count()函数获取时间间隔的值并进行输出。

延时操作示例：

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

int main() {
    using namespace std::chrono;

    std::cout << "Start" << std::endl;

    // 进行延时操作，暂停程序执行
    std::this_thread::sleep_for(std::chrono::seconds(2));

    std::cout << "End" << std::endl;

    return 0;
}

使用this_thread::sleep_for函数来进行延时操作，程序会暂停执行2秒钟，然后继续往下执行。

四、time_point的使用详解

4.1、time_point表示具体时间点的概念和使用方法

time_point（时间点）是std::chrono库中用于表示具体时间的类型。它表示了某个具体时刻的时间点，可以用于比较不同时间点的时间先后或时间间隔的计算。

time_point由两部分组成：时钟（Clock）和表示时间的持续时间（Duration）。

1.时钟（Clock）:

时钟是std::chrono库中的一种类型，用于测量时间的流逝。std::chrono库提供了几种不同的时钟类型，包括steady_clock（稳定时钟）、system_clock（系统时钟）和high_resolution_clock（高分辨率时钟）等。不同的时钟类型提供了不同的时间精度和适用范围。

2.表示时间的持续时间（Duration）:

Duration表示时间的长度或时间间隔，可以是纳秒、微秒、毫秒、秒、分钟、小时等不同的时间单位。Duration类的模板参数指定了时间长度的数值类型和时间单位。

使用方法：

要创建一个time_point对象，需要指定时钟类型和持续时间。可以使用当前的时钟来获取当前时间点，也可以根据需求指定一个特定的时间点。示例：

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;

    // 使用系统时钟获取当前时间点
    std::chrono::system_clock::time_point now = std::chrono::system_clock::now();

    // 创建一个表示特定时间点的time_point
    std::chrono::system_clock::time_point specific_time = 
        std::chrono::system_clock::time_point(std::chrono::seconds(1625100000));

    // 比较两个时间点的先后
    if (now > specific_time) {
        std::cout << "The current time is later than the specific time.\n";
    } else {
        std::cout << "The current time is earlier than the specific time.\n";
    }

    // 计算时间间隔
    std::chrono::duration<double> duration = now - specific_time;
    std::cout << "The duration between the two time points is: " << duration.count() << " seconds.\n";

    return 0;
}

通过std::chrono库中的system_clock获取了当前时间点，并通过手动指定一个特定的时间点。然后，可以比较这两个时间点的先后，并计算它们之间的时间间隔。

4.2、time_point与duration之间的关系

time_point表示一个具体的时间点，可以视为时间的参考点或标记。它由两个组成部分构成：时钟（Clock）和持续时间（Duration）。时钟指定了时间的基准和精度，而持续时间表示两个时间点之间的时间间隔。

duration表示一个时间长度或时间间隔，它可以是纳秒、微秒、毫秒、秒、分钟、小时等不同的时间单位。

duration模板类的参数指定了时间长度的数值类型和时间单位。持续时间的正负值决定了时间间隔是向前还是向后。

time_point和duration之间的关系：

• 通过time_point和duration的组合，可以表示一个时间点，也可以计算两个时间点之间的时间间隔。
• 可以在time_point上添加或减去某个duration，以获得新的time_point。例如，可以将一个time_point向前推进一个duration，或者将一个duration加上一个time_point来计算未来的时间点。
• 可以通过计算两个time_point之间的时间间隔，得到一个duration对象。这是通过减去一个time_point（较早的时间点）从另一个time_point（较晚的时间点）来实现的。

下面是一个使用time_point和duration的示例，展示了它们之间的关系：

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;

    // 获取当前时间点
    system_clock::time_point start = system_clock::now();

    // 进行一些耗时操作
    std::this_thread::sleep_for(std::chrono::seconds(2));

    // 获取后续的时间点
    system_clock::time_point end = system_clock::now();

    // 计算时间间隔
    duration<double> duration = duration_cast<duration<double>>(end - start);

    // 输出时间间隔
    std::cout << "Elapsed time: " << duration.count() << " seconds\n";

    return 0;
}

说明：使用system_clock获取了开始和结束的时间点，然后通过减法操作计算时间间隔duration。最后，使用duration的count()方法获取时间间隔的值，并输出结果。这个示例演示了如何结合使用time_point和duration来计算时间间隔。

4.3、如何创建、比较和操作time_point对象

演示了如何创建、比较和操作time_point对象：

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;

    // 创建一个time_point对象 - 使用系统时钟获取当前时间点
    system_clock::time_point now = system_clock::now();

    // 创建一个time_point对象 - 手动指定一个特定时间点
    system_clock::time_point specific_time = system_clock::time_point(seconds(1625100000));

    // 比较两个time_point对象的先后
    if (now > specific_time) {
        std::cout << "The current time is later than the specific time.\n";
    } else {
        std::cout << "The current time is earlier than the specific time.\n";
    }

    // 操作time_point对象，计算时间间隔
    system_clock::time_point future = now + hours(48);
    duration<double> duration = duration_cast<duration<double>>(future - now);
    std::cout << "The duration between now and future is: " << duration.count() << " seconds.\n";

    return 0;
}

说明：使用system_clock获取了当前时间点，并通过手动指定一个特定的时间点创建了另一个time_point对象。然后，比较这两个time_point对象的先后关系，并输出结果。接下来，操作time_point对象，通过将一个duration（48小时）加到当前时间点上，得到一个未来的时间点。最后，我们计算了当前时间点和未来时间点之间的时间间隔，并输出结果。

注意：在计算时间间隔时，使用了duration_cast将时间间隔转换为所需的duration类型（在这里是double类型）。

五、clock的使用详解

5.1、不同类型的clock

在std::chrono库中，存在三种不同类型的时钟：system_clock、steady_clock和high_resolution_clock。它们都用于表示时间点和测量时间间隔，但在实际应用中会有一些区别。

1.system_clock：

• system_clock是系统级别的时钟，它表示实时时钟，也就是指示当前时间的时钟。它的时间点是与系统的时钟相关联的，可能受到时钟调整和时区的影响。
• system_clock用于获取当前的系统时间，可以用来进行日常时间计算和显示。它通常被用作默认的时钟类型。
• system_clock的最小时间单位取决于系统，可能是秒、毫秒或微秒。

2.steady_clock：

• steady_clock是一个单调递增的时钟，不受任何时钟调整或时区的影响。它提供了一个稳定、可靠的时间基准，适合用于测量时间间隔和计算算法的执行时间。
• steady_clock的最小时间单位取决于实现，通常是纳秒或微秒级别。

3.high_resolution_clock：

• high_resolution_clock是一个可用于测量小时间间隔的时钟。它通常使用最高分辨率的时钟源来提供更高的时间精度。在大部分平台上，high_resolution_clock是steady_clock的别名，因此也是一个单调递增的时钟。
• high_resolution_clock的最小时间单位取决于实现，通常是纳秒或微秒级别。

使用不同类型的时钟的示例：

#include <iostream>
#include <chrono>

int main() {
    using namespace std::chrono;

    // 使用system_clock获取当前时间
    system_clock::time_point system_now = system_clock::now();

    // 使用steady_clock获取开始时间
    steady_clock::time_point steady_start = steady_clock::now();

    // 一些操作...

    // 使用steady_clock获取结束时间
    steady_clock::time_point steady_end = steady_clock::now();

    // 使用high_resolution_clock获取开始时间
    high_resolution_clock::time_point high_res_start = high_resolution_clock::now();

    // 一些操作...

    // 使用high_resolution_clock获取结束时间
    high_resolution_clock::time_point high_res_end = high_resolution_clock::now();

    // 输出时间间隔
    duration<double> steady_duration = duration_cast<duration<double>>(steady_end - steady_start);
    duration<double> high_res_duration = duration_cast<duration<double>>(high_res_end - high_res_start);

    std::cout << "Steady duration: " << steady_duration.count() << " seconds.\n";
    std::cout << "High resolution duration: " << high_res_duration.count() << " seconds.\n";

    return 0;
}

说明：使用system_clock获取了当前时间，使用steady_clock和high_resolution_clock获取了开始和结束时间。然后，通过减法操作计算了时间间隔，并使用duration_cast将时间间隔转换为double类型的秒数。最后，输出了steady_clock和high_resolution_clock的时间间隔。

5.2、每种clock的特点和适用场景

不同类型的时钟(system_clock、steady_clock和high_resolution_clock)具有不同的特点和适用场景

1.system_clock：

特点：system_clock是一个系统级别的时钟，用于表示实时时钟，它的时间点是与系统相关联的。它可以受到时钟调整和时区的影响。

适用场景：system_clock适用于获取当前的系统时间、进行日常时间计算和显示。它通常被用作默认的时钟类型。

2.steady_clock：

特点：steady_clock是一个单调递增的时钟，不受任何时钟调整或时区的影响，提供了一个稳定、可靠的时间基准。

适用场景：steady_clock适用于测量时间间隔、计算算法的执行时间等希望得到稳定和可靠时间测量的场景。由于不受时钟调整的影响，它特别适合用于计算程序的运行时间、测量短时间间隔等要求精确性的计时操作。

3.high_resolution_clock：

特点：high_resolution_clock是一个可用于测量小时间间隔的时钟，通常使用最高分辨率的时钟源来提供更高的时间精度。在大部分平台上，high_resolution_clock是steady_clock的别名，因此也是一个单调递增的时钟。

适用场景：high_resolution_clock可以用于需要更高时间精度的场景，比如测量微小的时间间隔、对性能进行优化的任务，或者需要尽可能精确的时间测量。

注意：不同的平台可能对这些时钟的实现有所不同，最小时间单位也可能有所不同。可以使用duration_cast将时间间隔转换为所需的时间单位（例如秒、毫秒、纳秒等）。

如果需要表示当前实时时间、进行日常时间计算和显示，可以使用system_clock。而如果需要测量时间间隔、计算算法的执行时间等，可以使用steady_clock。如果需要更高的时间精度，可以使用high_resolution_clock。

六、应用示例

定时任务。可以使用std::this_thread::sleep_for函数来创建定时任务。每隔一秒打印一次消息的示例：

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

int main() {
    while (true) {
        std::cout << "Hello, World!" << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
}

测量代码执行时间：使用std::chrono::steady_clock可以测量代码块的执行时间。测量排序算法的执行时间：

#include <iostream>
#include <chrono>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> nums = {5, 2, 8, 1, 9};

    auto start = std::chrono::steady_clock::now();
    std::sort(nums.begin(), nums.end());
    auto end = std::chrono::steady_clock::now();

    std::chrono::duration<double> diff = end - start;
    std::cout << "Sorting took " << diff.count() << " seconds." << std::endl;

    return 0;
}

使代码跨平台。使用std::chrono可以实现跨平台的时间处理，避免依赖于特定平台的系统调用。获取当前时间点并打印出来：

#include <iostream>
#include <chrono>

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

    std::cout << "Current time: " << std::ctime(&time) << std::endl;

    return 0;
}

时间格式化：std::chrono库提供了一些用于格式化时间的函数和类。可以使用std::put_time函数将时间对象格式化为字符串，并指定所需的时间格式。它接受一个时间对象和格式化字符串作为参数，返回一个格式化后的字符串。示例代码如下：

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

int main() {
    auto now = std::chrono::system_clock::now();
    std::time_t t = std::chrono::system_clock::to_time_t(now);
    std::cout << "Current time: " << std::put_time(std::localtime(&t), "%c") << std::endl;
    return 0;
}

说明：将当前时间格式化为日期和时间的字符串，并以本地时间格式（“%c”）进行输出。

总结

C++的std::chrono时间库提供了处理时间相关操作的功能。

核心概念：

时钟（Clock）：表示时间的源头，提供了时间的基准和刻度。常见的时钟有系统时钟（system_clock）、稳定时钟（steady_clock）和高精度时钟（high_resolution_clock）。

时间点（Time Point）：表示特定时钟上的一个时间。时间点可使用时钟的成员函数now()获取，也可以通过时钟的to_time_point()函数从时间表示转换得到。

时间间隔（Duration）：表示一段时间的表示，可以是秒、毫秒、微秒、纳秒等等。时间间隔的类型为duration，比如duration<int, std::ratio<1, 1000>>表示毫秒。

使用方法：

获取当前时间点：使用时钟的now()成员函数可以获取当前时间点，返回一个时间点对象。

std::chrono::system_clock::time_point now = std::chrono::system_clock::now();

计算时间间隔：使用时间点对象相减可以计算时间间隔，返回一个时间间隔对象。

std::chrono::duration<double> diff = end - start;
double seconds = diff.count();

休眠指定时间：使用std::this_thread::sleep_for()函数可以使当前线程休眠指定的时间间隔。

std::this_thread::sleep_for(std::chrono::seconds(1));

转换时间表示：可以通过时钟的成员函数to_time_t()将时间点对象转换为time_t表示，或使用ctime()函数将time_t转换为字符串表示。

std::time_t time = std::chrono::system_clock::to_time_t(now);
std::cout << "Current time: " << std::ctime(&time) << std::endl;

以上就是C++中std::chrono时间库的全面解析的详细内容，更多关于C++ std::chrono时间库的资料请关注脚本之家其它相关文章！