博主简介
一个热爱分享高性能服务器后台开发知识的博主,目标是通过理论与代码实践的结合,让世界上看似难以掌握的技术变得易于理解与掌握。技能涵盖了多个领域,包括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++标准库提供的一个时间处理库,提供了一个方便、灵活和精确的时间处理工具,用于在程序中进行时间相关的操作和计算。它具有以下重要性和作用:
精确的时间计量: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命名空间是C++标准库中的一个命名空间,它包含了一组用于处理时间和时间相关操作的类和函数。该命名空间提供了丰富的时间处理功能,旨在方便进行时间计算、测量和控制。
std::chrono命名空间的主要作用和用途:
提供时间单位和精度的定义:std::chrono命名空间定义了一系列时间单位,如秒(seconds)、毫秒(milliseconds)、微秒(microseconds)和纳秒(nanoseconds),以及精度等级,如高精度时钟(high_resolution_clock)和稳定时钟(steady_clock)。这些定义使得时间计算和测量更加灵活和精确。
定义时间段和时间点的概念:std::chrono命名空间提供了表示时间段(duration)和时间点(time_point)的相关类,包括std::chrono::duration和std::chrono::time_point。时间段表示两个时间点之间的时间差,时间点表示具体的时间。
支持时间的计算和操作:该命名空间提供了各种用于时间计算和操作的函数和操作符。例如,可以通过相加或相减两个时间点或时间段来计算时间的差异、延迟或间隔。也可以比较两个时间点的先后顺序,判断时间的先后关系。
管理和控制时间流逝:std::chrono命名空间提供了函数和工具,可用于管理和控制时间的流逝。例如,可以获取当前的系统时间和时钟时间,或者获取程序执行的实际时间。还可以设置定时任务或者延时执行代码。
std::chrono命名空间是C++标准库的一部分,因此它具有跨平台的兼容性,并且在不同的操作系统中都能正常工作。
时间库的基本组成部分包括duration(时间段)、time_point(时间点)和clock(时钟)。它们相互配合,用于表示和处理时间的不同方面。
duration(时间段):
duration是时间库中表示时间段的类。它表示两个时间点之间的时间差。时间段可以用秒(seconds)、毫秒(milliseconds)、微秒(microseconds)等不同的单位来表示。duration类的模板参数包括时间单位和所需的精度。比如:std::chrono::duration
表示毫秒级别的时间段。在使用Duration时,可以进行加减、比较和表示等操作。
time_point(时间点):
time_point表示一个特定的时间点,可以理解为时间的戳记。时间点和时间段之间可以进行加减运算,用于计算时间的差异或延迟。time_point类的模板参数包括所采用的时钟类型和时间单位。比如:std::chrono::time_point
表示系统时钟下的纳秒级时间点。可以获取当前的时间点、比较不同时间点的顺序,以及对时间点进行格式化等操作。
clock(时钟):
clock是时间库中的时钟类,用于提供时间的基准和计量。不同的时钟类型提供不同的时间精度和功能。常用的时钟类型有系统时钟(system_clock)、稳定时钟(steady_clock)和高精度时钟(high_resolution_clock)。系统时钟提供了与操作系统相关的时间,稳定时钟提供了稳定的、不受系统时间变化影响的时间,而高精度时钟提供了更高的时间精度。时钟类可以获取当前时间,计算时间的间隔和延迟等。
这三个基本组成部分相互配合,使时间库具有了强大的时间处理能力。Duration表示时间段,Time_point表示时间点,而Clock则提供了时钟的基准。通过使用它们,可以对时间进行准确的计算、比较和操作,从而灵活地处理时间相关的任务和逻辑。
Duration(时间段)是时间库中表示时间间隔的类,用于表示两个时间点之间的时间差。
表示和定义duration:
duration类是一个模板类,模板参数包括时间单位和精度。时间单位可以是秒(seconds)、毫秒(milliseconds)、微秒(microseconds)或纳秒(nanoseconds),精度可以是整数类型(int、long)、浮点类型(float、double)等。例如,可以定义一个表示毫秒级别的时间段:std::chrono::duration
。
创建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对象
std::chrono::duration<int, std::milli> duration(500);
int milliseconds = duration.count(); // 返回500
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毫秒
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纳秒
std::chrono::nanoseconds
std::chrono::microseconds
std::chrono::milliseconds
std::chrono::seconds
std::chrono::minutes
std::chrono::hours
这些单位可以提供不同精度的时间间隔表示。
例如,可以选择使用以下精度选项:
std::chrono::duration
std::chrono::duration
std::chrono::duration
std::chrono::duration
例如,如果需要表示毫秒级别的时间间隔,可以选择std::chrono::duration
,它使用整数类型表示毫秒。
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);
以下是一些使用Duration的具体示例,涵盖时间计算和延时操作:
#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()
函数获取时间间隔的值并进行输出。
#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(时间点)是std::chrono库中用于表示具体时间的类型。它表示了某个具体时刻的时间点,可以用于比较不同时间点的时间先后或时间间隔的计算。
time_point由两部分组成:时钟(Clock)和表示时间的持续时间(Duration)。
时钟(Clock):
时钟是std::chrono库中的一种类型,用于测量时间的流逝。std::chrono库提供了几种不同的时钟类型,包括steady_clock(稳定时钟)、system_clock(系统时钟)和high_resolution_clock(高分辨率时钟)等。不同的时钟类型提供了不同的时间精度和适用范围。
表示时间的持续时间(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获取了当前时间点,并通过手动指定一个特定的时间点。然后,可以比较这两个时间点的先后,并计算它们之间的时间间隔。
time_point表示一个具体的时间点,可以视为时间的参考点或标记。它由两个组成部分构成:时钟(Clock)和持续时间(Duration)。时钟指定了时间的基准和精度,而持续时间表示两个时间点之间的时间间隔。
duration表示一个时间长度或时间间隔,它可以是纳秒、微秒、毫秒、秒、分钟、小时等不同的时间单位。duration模板类的参数指定了时间长度的数值类型和时间单位。持续时间的正负值决定了时间间隔是向前还是向后。
time_point和duration之间的关系:
下面是一个使用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来计算时间间隔。
演示了如何创建、比较和操作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类型)。
在std::chrono库中,存在三种不同类型的时钟:system_clock、steady_clock和high_resolution_clock。它们都用于表示时间点和测量时间间隔,但在实际应用中会有一些区别。
system_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的时间间隔。
不同类型的时钟(system_clock、steady_clock和high_resolution_clock)具有不同的特点和适用场景
system_clock:
steady_clock:
high_resolution_clock:
注意:不同的平台可能对这些时钟的实现有所不同,最小时间单位也可能有所不同。可以使用duration_cast
将时间间隔转换为所需的时间单位(例如秒、毫秒、纳秒等)。
如果需要表示当前实时时间、进行日常时间计算和显示,可以使用system_clock。而如果需要测量时间间隔、计算算法的执行时间等,可以使用steady_clock。如果需要更高的时间精度,可以使用high_resolution_clock。
#include
#include
#include
int main() {
while (true) {
std::cout << "Hello, World!" << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(1));
}
}
#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;
}
#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;
}
#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时间库提供了处理时间相关操作的功能。
核心概念:
时钟(Clock):表示时间的源头,提供了时间的基准和刻度。常见的时钟有系统时钟(system_clock)、稳定时钟(steady_clock)和高精度时钟(high_resolution_clock)。
时间点(Time Point):表示特定时钟上的一个时间。时间点可使用时钟的成员函数now()获取,也可以通过时钟的to_time_point()函数从时间表示转换得到。
时间间隔(Duration):表示一段时间的表示,可以是秒、毫秒、微秒、纳秒等等。时间间隔的类型为duration,比如duration
使用方法:
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::chrono::seconds(1));
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时间库的详细说明和示例代码。官方文档可以帮助深入了解每个类、函数和成员的用法和语义。
C++ Reference:C++ Reference是一个权威的C++参考网站,提供了std::chrono时间库的详细文档和示例代码。可以在该网站上查找特定类、函数或成员,并了解它们的用法和示例。
推荐书籍:《C++ Concurrency in Action: Practical Multithreading》和《Effective Modern C++: 42 Specific Ways to Improve Your Use of C++11 and C++14》。