再也不被时间束缚:C++ stdchrono时间库全面解析

C++ stdchrono时间库全面解析

  • 一、引言
  • 二、C++ std::chrono时间库概述
    • 2.1、std::chrono命名空间的作用和用途
    • 2.2、基本组成部分:duration、time_point和clock
  • 三、duration的使用详解
    • 3.1、duration表示时间段的概念和使用方法
    • 3.2、duration的各种单位和精度选项
    • 3.3、使用示例
  • 四、time_point的使用详解
    • 4.1、time_point表示具体时间点的概念和使用方法
    • 4.2、time_point与duration之间的关系
    • 4.3、如何创建、比较和操作time_point对象
  • 五、clock的使用详解
    • 5.1、不同类型的clock
    • 5.2、每种clock的特点和适用场景
  • 六、应用示例
  • 总结

博主简介


一个热爱分享高性能服务器后台开发知识的博主,目标是通过理论与代码实践的结合,让世界上看似难以掌握的技术变得易于理解与掌握。技能涵盖了多个领域,包括C/C++、Linux、数据结构与算法、Nginx、MySQL、Redis、fastdfs、kafka、Docker、TCP/IP、协程、DPDK等。公众号《Lion 莱恩呀》每日推送新文章。

️ CSDN实力新星、CSDN博客专家、华为云云享专家、阿里云专家博主


摘要: 这是一篇介绍C++ std::chrono时间库的全面文章。在现代软件开发中,时间处理是一个重要的部分,而std::chrono时间库提供了丰富的功能和灵活的接口来处理时间相关的操作,使得开发者能够更好地控制和管理时间。

本文首先介绍了std::chrono时间库的核心概念,包括时钟、时间点和时间间隔。其中,时钟作为时间的源头,提供了基准和刻度;时间点表示特定时钟上的一个时间;时间间隔表示一段时间的表示。

接下来,本文详细讲解了std::chrono时间库的常见应用场景。其中包括定时任务的创建,通过std::this_thread::sleep_for函数来实现;测量代码执行时间,利用std::chrono::steady_clock来计算代码块的执行时间;以及实现跨平台的时间处理,通过std::chrono::system_clock来获取当前时间点并进行转换。

此外,本文还介绍了std::chrono时间库的高级特性,如时间格式化、时钟类型的扩展和自定义时间单位。

一、引言

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

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

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

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

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

  5. 时间点和时间段的处理:该库提供了表示时间点(time_point)和时间段(duration)的相关类,可以对时间进行精确刻度和处理。时间点表示具体的时间,时间段表示两个时间点之间的时间差。

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

目标:

  1. 首先对C++ std::chrono时间库进行全面而清晰的概述,解释其在编程中的重要性和作用。

  2. 详细讲解C++ std::chrono时间库的组成部分,包括duration、time_point和clock。了解它们是如何相互配合工作的,以及如何使用它们来进行时间相关的操作。

  3. 供详细的使用攻略,涵盖duration(时间段)的使用方法、单位和精度的选择、示例代码等;time_point(时间点)的创建、比较和操作方法,以及相关的应用场景;不同类型的时钟(clock)的特点、适用场景和使用方法等。

  4. 除了基本的使用方法,还将探讨一些高级技巧和实践,如时区处理、时间格式转换等。我们还将解决一些常见的时间相关问题,提供实用的技巧和最佳实践,更高效、准确地使用时间库,解放代码从时间束缚中。

二、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(时钟)。它们相互配合,用于表示和处理时间的不同方面。

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

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

  3. 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

  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对象
  1. 访问duration的值:
    可以使用成员函数count()来访问Duration对象的值。count()函数返回Duration对象表示的时间段值,以它所定义的时间单位返回。例如:
std::chrono::duration<int, std::milli> duration(500);
int milliseconds = duration.count(); // 返回500
  1. 操作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毫秒
  1. 比较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的各种单位和精度选项

  1. 时间单位(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

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

  1. 精度(Precision):
    精度表示duration所使用的数值类型,可以是整型(整数类型)或浮点型(浮点数类型)。可以使用标准数值类型(如int、long、float、double)作为Duration的数值类型,并与所选的时间单位进行配对。

例如,可以选择使用以下精度选项:

  • 整数类型精度:std::chrono::duration
  • 长整数类型精度:std::chrono::duration
  • 浮点类型精度:std::chrono::duration
  • 双精度类型精度:std::chrono::duration

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

  1. 下面是一些示例,展示了如何使用不同的时间单位和精度选项:
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的具体示例,涵盖时间计算和延时操作:

  1. 时间计算示例:
#include 
#include 

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()函数获取时间间隔的值并进行输出。

  1. 延时操作示例:
#include 
#include 
#include 

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 
#include 

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之间的关系:

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

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

#include 
#include 

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 
#include 

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 
#include 

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。

六、应用示例

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

int main() {
    while (true) {
        std::cout << "Hello, World!" << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
}
  1. 测量代码执行时间:使用std::chrono::steady_clock可以测量代码块的执行时间。测量排序算法的执行时间:
#include 
#include 
#include 
#include 

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;
}
  1. 使代码跨平台。使用std::chrono可以实现跨平台的时间处理,避免依赖于特定平台的系统调用。获取当前时间点并打印出来:
#include 
#include 

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;
}
  1. 时间格式化:std::chrono库提供了一些用于格式化时间的函数和类。可以使用std::put_time函数将时间对象格式化为字符串,并指定所需的时间格式。它接受一个时间对象和格式化字符串作为参数,返回一个格式化后的字符串。示例代码如下:
#include 
#include 
#include 

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时间库提供了处理时间相关操作的功能。
核心概念:

  1. 时钟(Clock):表示时间的源头,提供了时间的基准和刻度。常见的时钟有系统时钟(system_clock)、稳定时钟(steady_clock)和高精度时钟(high_resolution_clock)。

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

  3. 时间间隔(Duration):表示一段时间的表示,可以是秒、毫秒、微秒、纳秒等等。时间间隔的类型为duration,比如duration>表示毫秒。

使用方法:

  1. 获取当前时间点:使用时钟的now()成员函数可以获取当前时间点,返回一个时间点对象。
std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
  1. 计算时间间隔:使用时间点对象相减可以计算时间间隔,返回一个时间间隔对象。
std::chrono::duration<double> diff = end - start;
double seconds = diff.count();
  1. 休眠指定时间:使用std::this_thread::sleep_for()函数可以使当前线程休眠指定的时间间隔。
std::this_thread::sleep_for(std::chrono::seconds(1));
  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时间库的推荐资源:

  1. 官方文档:可以查阅C++标准库的官方文档,其中包含了std::chrono时间库的详细说明和示例代码。官方文档可以帮助深入了解每个类、函数和成员的用法和语义。

  2. C++ Reference:C++ Reference是一个权威的C++参考网站,提供了std::chrono时间库的详细文档和示例代码。可以在该网站上查找特定类、函数或成员,并了解它们的用法和示例。

  3. 推荐书籍:《C++ Concurrency in Action: Practical Multithreading》和《Effective Modern C++: 42 Specific Ways to Improve Your Use of C++11 and C++14》。

再也不被时间束缚:C++ stdchrono时间库全面解析_第2张图片

你可能感兴趣的:(C/C++,c++,开发语言,时间库,chrono库,linux,visualstudio,数据结构)