摘自:https://blog.csdn.net/u010429831/article/details/122722187
一、时间日期类型
Linux下常用的时间类型有6个:time_t, clock_t, struct timeb, struct timeval, struct timespec, struct tm
1.1 time_t 类型
time_t 是一个长整型,一般用来表示从1970年1月1日0时0分0秒以来的秒数。
该类型定义在 #include <sys/time.h> 头文件中。
一般通过 time_t time = time(NULL); 获取。
1.2 clock_t 类型
clock_t 也是一个长整型。
#include <time.h>
#ifndef _CLOCK_T_DEFINED
typedef long clock_t; //clock_t是一个长整形数
#define _CLOCK_T_DEFINED
#endif
//在time.h文件中,还定义了一个常量 CLOCKS_PER_SEC,它用来表示一秒钟会有多少个时钟计时单元
#define CLOCKS_PER_SEC ((clock_t)1000000)
通常使用 clock() 函数返回获取。
#include <time.h>
clock_t clock(void);
//表示进程占用的cpu时间,精确到微秒。
//这个函数返回值为程序开始启动到程序调用clock()函数时之间的CPU时钟计时单元(clock tick)数。
//如果想返回以秒为单位的时间数,可以使用下面的方式:
clock_t start, end, duration;
start = clock();
...
end = clock();
duration = (end - start) / CLOCKS_PER_SEC;
1.3 struct timeb 结构体
#include <time.h>
struct timeb
{
time_t time; //秒数
unsigned short millitm; //毫秒数
short timezone; //时区,当前时区和Greenwich相差的时间,单位为分钟
short dstflag; //夏令时标志,如果为非0表示启用夏令时
};
使用 ftime() 函数获取当前的时间和日期:ftime(&tb);
1.4 struct timeval 结构体
#include <sys/time.h>
struct timeval
{
long tv_sec; //seconds:秒
long tv_usec; //microseconds:微秒
};
由 int gettimeofday(struct timeval *tv, struct timezone *tz); 函数获取。
struct timezone 时区结构体
#include <sys/time.h>
struct timezone
{
int tz_minuteswest; //和Greewich(格林威治)时间差了多少分钟
int tz_dsttime; //夏令时Type
};
//常见的DST类型如下:
#define DST_NONE 0 //not on dst
#define DST_USA 1 //USA style dst
#define DST_AUST 2 //Australian style dst
#define DST_WET 3 //Western European dst
#define DST_MET 4 //Middle European dst
#define DST_EET 5 //Eastern European dst
#define DST_CAN 6 //Canada
1.5 struct timespec 结构体
#include <time.h>
struct timespec
{
time_t tv_sec; //seconds:秒
long tv_nsec; //nanoseconds:纳秒
};
一般由 long clock_gettime (clockid_t which_clock, struct timespec *tp); 函数获取。
1.6 struct tm 结构体
#include <time.h>
struct tm {
int tm_sec; //秒 – 取值区间为[0,59]
int tm_min; //分 - 取值区间为[0,59]
int tm_hour; //时 - 取值区间为[0,23]
int tm_mday; //一个月中的日期 - 取值区间为[1,31]
int tm_mon; //月份(从一月开始,0代表一月) - 取值区间为[0,11]
int tm_year; //年份,其值等于实际年份减去1900
int tm_wday; //星期 – 取值区间为[0,6],其中0代表星期天,1代表星期一,以此类推
int tm_yday; //从每年的1月1日开始的天数 – 取值区间为[0,365],其中0代表1月1日,1代表1月2日,以此类推
int tm_isdst; //夏令时标识符,实行夏令时的时候,tm_isdst为正。不实行夏令时的进候,tm_isdst为0;不了解情况时,tm_isdst()为负
};
struct tm 结构体通常由 gmtime, localtime, mktime 等时间函数返回。
二、常用时间日期函数
2.1 time() 函数 — 提供秒级时间精度
#include <time.h>
time_t time(time_t *t);
【使用说明】
(1)若函数实参为 NULL, 则返回从1970年1月1日0时0分0秒到现在(系统时间)所经过的秒;
(2)若函数实参非空,则将返回的值存方在由指针 t 所指向的内存单元中。
//使用示例1
time_t now = time(NULL);
//使用示例2
time_t now;
time(&now);
printf("%s", ctime(&now)); //ctime()将时间和日期以字符串格式返回
2.2 gettimeofday() 函数 — 提供微秒级时间精度
#include <sys/time.h>
#include <unistd.h>
int gettimeofday(struct timeval *tv ,struct timezone *tz);
【函数说明】
该函数可以获取两方面的时间信息,一个是可以获取到从1970年1月1日0时0分0秒到现在(系统时间)所经过的微秒,精度相比 time() 函数精度有所提升;另外还可以获取到系统的时区信息。
【返回值】gettimeofday()函数成功返回0,否则返回-1,并将错误码存放在 errno 全局变量中。errno 在 <errno.h> 头文件中定义。
【使用说明】
在实际开发中,gettimeofday 中的 tz 参数实际很少使用,因为各种原因,一直未能实现(所获取出来的值恒为0),因此,通常将此处直接写成 NULL。
与gettimeofday()函数相对应的是 settimeofday()函数,它可以设置实时时间RTC。但之前必须要具有root权限。
settimeofday()
#include <sys/time.h>
#include <unistd.h>
int settimeofday(const struct timeval *tv, const struct timezone *tz);
【函数说明】settimeofday()会把目前时间设成由 tv 所指的结构信息,当地时区信息则设成 tz 所指的结构。
【返回值】成功则返回0,失败返回-1,错误代码存于errno。
错误代码:
EPERM 并非由root 权限调用settimeofday(),权限不够。
EINVAL 时区或某个数据是不正确的,无法正确设置时间。
<注意> 在Linux下,只有root 权限才能使用此函数修改时间。
//使用示例
struct timeval tv;
gettimeofday(&tv,NULL); //获取以struct timeval结构体保存的时间信息
time_t sec, usec;
sec = tv.tv_sec;
usec = tv.tv_usec;
2.3 clock_gettime() 函数 — 提供纳秒级时间精度
#include <time.h>
int clock_getres(clockid_t clk_id, struct timespec *res);
int clock_gettime(clockid_t clk_id, struct timespec *tp);
int clock_settime(clockid_t clk_id, const struct timespec *tp);
【函数说明】
clock_getres() 函数返回由 clk_id 指定的时钟的分辨率,并将其放置在res指向的位置。但是,如果res为 NULL,则不返回任何分辨率。
clock_gettime() 函数返回由 clk_id 指定的时钟的当前值,并将其放置在tp指向的位置。
clock_settime() 函数将 clk_id 指定的时钟设置为 tp指向的时间。当tp不是指定时钟分辨率的倍数时,将使用小于tp的 tp 的最大倍数 。
【参数说明】
clk_id:用于指定计时时钟的类型,有以下4种:
CLOCK_REALTIME:系统实时时间,随系统实时时间改变而改变,即从UTC 1970-1-1 0:0:0 开始计时,中间时刻如果系统时间被用户该成其他,则对应的时间相应改变。
CLOCK_MONOTONIC:从系统启动这一刻起开始计时,不受系统时间被用户改变的影响。
CLOCK_PROCESS_CPUTIME_ID:本进程到运行到当前代码系统CPU所花费的时间。
CLOCK_THREAD_CPUTIME_ID:本线程到运行到当前代码系统CPU花费的时间。
res:指向clock_getres()存储检索到的时钟分辨率的位置。
tp:指向 timespec 结构,该结构用于存储使用 clock_gettime() 检索的时间值或包含要使用 clock_settime() 设置的新时间值。
【返回值】成功时,这些函数返回 0;否则,这些函数返回 -1 ,并将 errno 设置为以下之一:
EFAULT
clock_id 参数是一个未知时钟类型。
EINVAL
clock_id 参数未识别已知时钟或为 clock_settime() 的 tp 指定了无效值。
EPERM
调用clock_settime()的进程缺少设置指定时钟的适当权限。需要 root 权限。
范例:
#include <stdio.h>
#include <string.h>
#include <time.h>
int main()
{
struct timespec ts;
memset(&ts, 0, sizeof(struct timespec));
clock_gettime(CLOCK_REALTIME, &ts);
printf("CLOCK_REALTIME: %d, %d\n", ts.tv_sec, ts.tv_nsec);
clock_gettime(CLOCK_MONOTONIC, &ts); //打印出来的时间跟 cat /proc/uptime 第一个参数一样
printf("CLOCK_MONOTONIC: %d, %d\n", ts.tv_sec, ts.tv_nsec);
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts);
printf("CLOCK_PROCESS_CPUTIME_ID: %d, %d\n", ts.tv_sec, ts.tv_nsec);
clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts);
printf("CLOCK_THREAD_CPUTIME_ID: %d, %d\n", ts.tv_sec, ts.tv_nsec);
printf("time(): %d seconds\n", time(NULL));
return 0;
}
运行结果:
CLOCK_REALTIME: 1645960150, 566539139
CLOCK_MONOTONIC: 13078, 97392275
CLOCK_PROCESS_CPUTIME_ID: 0, 2632933
CLOCK_THREAD_CPUTIME_ID: 0, 2643581
time(): 1645960150 seconds
2.4 asctime()、gmtime()、ctime()、localtime()、mktime()
#include <time.h>
char *asctime(const struct tm *tm);
char *asctime_r(const struct tm *tm, char *buf);
char *ctime(const time_t *timep);
char *ctime_r(const time_t *timep, char *buf);
struct tm *gmtime(const time_t *timep);
struct tm *gmtime_r(const time_t *timep, struct tm *result);
struct tm *localtime(const time_t *timep);
struct tm *localtime_r(const time_t *timep, struct tm *result);
time_t mktime(struct tm *tm);
gmtime、localtime 和 mktime 函数实现了 time_t 时间类型和 struct tm 时间结构体类型的互换功能,而 ctime 函数实现了 time_t 类型转换为时间字符串格式化功能。
以上四个有后缀为 _r 的函数表示的是其对应的线程安全函数版本,用于多线程环境下。
asctime()
【函数说明】asctime() 将参数 timep 所指的 tm 结构中的信息转换成真实世界所使用的时间日期表示方法,然后将结果以字符串形式返回。此函数已经由时区转换成当地时间,字符串格式为:"Wed Jun 30 21:49:08 1993"。
【返回值】返回一个字符串,表示目前当地的时间日期。该函数与 ctime() 函数的不同之处在于传入的参数类型不同:ctime 传入的参数类型是 time_t,而asctime 传入的是 struct tm。
【使用说明】asctime() 函数通常与 time()、gmtime() 或 localtime() 函数一起配合使用。范例如下:
#include <stdio.h>
#include <time.h>
int main()
{
time_t now;
time(&now);
printf("now=%u\n",now);
printf("time=%s\n", asctime(gmtime(&now)));
return 0;
}
运行结果:
now=1645885210
time=Sat Feb 26 14:20:10 2022
ctime()
【函数说明】将参数 timep 所指的 time_t 类型的时间信息转换成真实世界所使用的时间日期表示方法,然后将结果以字符串形式返回。
【返回值】返回一个字符串,表示目前当地的时间日期。该函数的功能与 asctime 函数类型,只是传入的参数类型不同。
范例:
#include <stdio.h>
#include <time.h>
int main()
{
time_t now;
time(&now);
printf("now=%u\n",now);
printf("time=%s\n", ctime(&now));
return 0;
}
运行结果:
now=1645885675
time=Sat Feb 26 22:27:55 2022
gmtime()
【函数说明】将参数 timep 所指的 time_t 类型中的时间信息转换成真实世界所使用的时间日期表示方法,然后将结果由结构体 tm 返回。注意该函数获取的是格林威治时间,而不是你所在的本地时间。
【返回值】返回由结构体 tm 代表的目前 UTC 时间。也就是说时间日期信息存放在 tm 结构体中。
【使用说明】gmtime 函数返回的是格林威治时间,而不是你所在地的本地时间。格林威治时间+8小时,才是我们中国的北京时间。如果要获取本地时间,并使用 tm 返回,应当使用 localtime 函数。
范例:
#include <stdio.h>
#include <time.h>
int main()
{
time_t now;
struct tm *p_tm;
char buf[256]={0};
time(&now);
p_tm = gmtime(&now); //将time_t时间类型转换为 struct tm 时间结构体类型
sprintf(buf, "%4d-%02d-%02d %02d:%02d:%02d", p_tm->tm_year+1900, p_tm->tm_mon+1, p_tm->tm_mday,
p_tm->tm_hour, p_tm->tm_min, p_tm->tm_sec);
printf("Greenwich time=%s\n", buf);
return 0;
}
运行结果:
Greenwich time=2022-02-26 14:49:36
localtime()
【函数说明】将参数 timep 所指的 time_t 类型中的信息转换成真实世界所使用的时间日期表示方法,然后将结果由结构 tm 返回。函数返回的时间日期已经转换成当地时区。
【返回值】返回结构 tm 代表目前的当地时间。在我们中国就是北京时间。
范例:修改 gmtime 函数中的范例,输出当地时间的字符串格式。
#include <stdio.h>
#include <time.h>
int main()
{
time_t now;
struct tm *p_tm;
char buf[256]={0};
time(&now);
p_tm = localtime(&now); //将time_t时间类型转换为 struct tm 时间结构体类型
sprintf(buf, "%4d-%02d-%02d %02d:%02d:%02d", p_tm->tm_year+1900, p_tm->tm_mon+1, p_tm->tm_mday,
p_tm->tm_hour, p_tm->tm_min, p_tm->tm_sec);
printf("Beijing time=%s\n", buf);
return 0;
}
运行结果:
Beijing time=2022-02-26 23:01:12
mktime()
【函数说明】用来将参数 timep 所指的 tm 结构时间数据转换成从公元1970年1月1日0时0分0 秒算起至今的UTC时间所经过的秒数,相当于调用 time()函数的返回值。
【返回值】返回经过的秒数。
【函数使用】一般先是使用 localtime 函数返回 tm 结构的本地时间,然后使用 mktime 函数获得从 Epoch 开始到当前时间所经过的秒数。Epoch 指的是公元1970年1月1日0时0分0秒时刻。
范例:
#include <stdio.h>
#include <time.h>
int main()
{
time_t now;
struct tm *p_tm;
time(&now);
printf("time():%d\n", now);
p_tm = localtime(&now); //将time_t时间类型转换为 struct tm 时间结构体类型
now = mktime(p_tm); //将struct tm 时间结构体类型转换为 time_t 时间类型
printf("time()->localtime()->mktime():%d\n", now);
return 0;
}
运行结果:
time():1645888684
time()->localtime()->mktime():1645888684
2.5 timegm()、timelocal() 函数
#include <time.h>
time_t timegm(struct tm *tm);
time_t timelocal(struct tm *tm);
【函数说明】timegm() 函数是 gmtime() 的逆置函数;timelocal() 函数是 localtime() 的逆置函数。将 tm 结构体所表示的时间转换为从 Epoch 时刻开始所经过的时间秒数。Epoch 指的是公元1970年1月1日0时0分0秒时刻。这两个函数都是线程安全的。
【返回值】返回经过的秒数。
范例:
#include <stdio.h>
#include <time.h>
int main()
{
time_t now, seconds;
struct tm *p_tm;
time(&now);
printf("time():%d\n", now);
p_tm = gmtime(&now); //将time_t时间类型转换为 struct tm 时间结构体类型
seconds = timegm(p_tm); //将struct tm 时间结构体类型转换为 time_t 时间类型
printf("timegm():%d\n", seconds);
p_tm = localtime(&now);
seconds = timelocal(p_tm);
printf("timelocal():%d\n", seconds);
return 0;
}
运行结果:
time():1645889946
timegm():1645889946
timelocal():1645889946
2.6 strftime()、strptime() — 自定义时间格式函数
#include <time.h>
size_t strftime(char *s, size_t max, const char *format,
const struct tm *tm);
char *strptime(const char *s, const char *format, struct tm *tm);
strftime()
【函数说明】strftime 函数的功能是将由 tm 结构体指针所指的时间按照 format 指针所指的格式输出到由 s 指针所指向的存储空间中,其中 max 是指存储空间允许存放的最大字符个数(即字符数组长度-1)。
【返回值】成功,返回写入存储空间的字符个数;失败,返回0。
【函数使用】strftime() 函数的操作有些类似于sprintf():识别以百分号(%)开始的格式命令集合,格式化输出结果放在一个字符串中。
格式命令如下,注意它们是区分大小写的:
%a 星期几的简写
%A 星期几的全称
%b 月分的简写
%B 月份的全称
%c 标准的日期的时间串
%C 年份的后两位数字
%d 十进制表示的每月的第几天
%D 月/天/年
%e 在两字符域中,十进制表示的每月的第几天
%F 年-月-日
%g 年份的后两位数字,使用基于周的年
%G 年分,使用基于周的年
%h 简写的月份名
%H 24小时制的小时
%I 12小时制的小时
%j 十进制表示的每年的第几天
%m 十进制表示的月份
%M 十时制表示的分钟数
%n 新行符
%p 本地的AM或PM的等价显示
%r 12小时的时间
%R 显示小时和分钟:hh:mm
%S 十进制的秒数
%t 水平制表符
%T 显示时分秒:hh:mm:ss
%u 每周的第几天,星期一为第一天 (值从0到6,星期一为0)
%U 第年的第几周,把星期日做为第一天(值从0到53)
%V 每年的第几周,使用基于周的年
%w 十进制表示的星期几(值从0到6,星期天为0)
%W 每年的第几周,把星期一做为第一天(值从0到53)
%x 标准的日期串
%X 标准的时间串
%y 不带世纪的十进制年份(值从0到99)
%Y 带世纪部分的十制年份
%z,%Z 时区名称,如果不能得到时区名称则返回空字符。
%% 百分号
范例:
#include <stdio.h>
#include <time.h>
int main()
{
time_t now;
struct tm *p_tm;
char buf[256]={0};
now = time(NULL);
p_tm = localtime(&now);
strftime(buf, sizeof(buf)-1, "%F %T %a", p_tm);
printf("local time=%s\n", buf);
return 0;
}
运行结果:
local time=2022-02-27 00:23:46 Sun
strptime()
【函数说明】strptime 函数是 strftime 函数的逆过程,它是将字符指针 s 指向的时间字符串,按照 format 格式转换为 tm 结构体时间格式。format 格式的书写与 strftime 的相同。
【返回值】成功,则返回第一个未处理的字符的指针;失败,返回 NULL。
【函数使用】该函数类似于 scanf 函数,解析时间字符串为 tm 时间格式。
范例:
#include <stdio.h>
#include <string.h>
#include <time.h>
int main()
{
time_t now;
struct tm tm;
char buf[256]={0};
memset(&tm, 0, sizeof(struct tm));
strptime("2022-02-27 00:57:30", "%Y-%m-%d %H:%M:%S", &tm);
strftime(buf, sizeof(buf)-1, "%D %H:%M:%S %a", &tm);
printf("local time=%s\n", buf);
return 0;
}
运行结果:
local time=02/27/22 00:57:30 Sun
2.7 difftime() — 计算时间持续的长度函数
#include <time.h>
double difftime(time_t time1, time_t time0);
【函数说明】计算time1 和 time0 之间相差的秒数(time1 - time0)。这两个时间是在日历时间中指定的,表示了自纪元 Epoch(协调世界时 UTC:1970-01-01 00:00:00)起经过的时间。
【返回值】返回 (time1 - time0) 的时间秒数。
范例:
#include <stdio.h>
#include <time.h>
int main()
{
time_t start, end;
start = time(NULL);
getchar();
end = time(NULL);
printf("The pause time: %.2f seconds\n", difftime(end, start));
return 0;
}
运行结果:
The pause time: 4.00 seconds
2.8 睡眠函数:sleep()、usleep()、nanosleep()
#include <unistd.h>
unsigned int sleep(unsigned int seconds); //秒数
int usleep(useconds_t usec); //微秒数
#include <time.h>
int nanosleep(const struct timespec *rqtp, struct timespec *rmtp); //纳秒数
sleep() 函数
【函数说明】sleep 函数会让进程/线程进入睡眠状态 seconds 秒。
【返回值】如果睡眠时间达到了参数 seconds 指定的秒数,则返回 0;如果 sleep 函数被信号中断执行,则返回剩余睡眠的秒数。
usleep() 函数
【函数说明】usleep 函数的功能和 sleep 一样,只是它提供的是更精确的时间粒度,单位为微秒(1 秒 = 一百万微秒)。
【返回值】成功,返回 0;失败,返回 -1,并将错误码存放在 errno 全局变量中。errno 在 <errno.h> 头文件中定义。
(1) 如果 usleep 函数被信号中断执行,也是返回 -1,并将 errno 设置为 EINTR 错误码。
(2) 如果传给形参 usec 的实参值大于一百万,系统也会认为这是一个错误,返回 -1,并将 errno 设置为 EINVAL 错误码。
nanosleep() 函数
【函数说明】nanosleep 函数可以利用 struct timespec 时间结构体提供纳秒粒度的时间精度。nanosleep 会让程序睡眠 rqtp 指针指向的时间,若 rmtp 参数为 non-NULL,而且睡眠时间未到期就返回了,将会把剩余的时间存放在 rmtp 指针指向的 timespec 结构变量中。如果不需要的话,可以将 rmtp 参数置为 NULL。
【返回值】如果达到了要求的睡眠时间,则返回 0;否则,返回 -1,并将错误码存放在 errno 全局变量中。
(1) 如果 nanosleep 函数被信号中断,返回 -1,并将 errno 设置为 EINTR 错误码。
(2) rqtp 指针指向的 timespec 结构体变量的成员 tv_nsec 的值设置为小于 0 或者大于等于 10亿,返回 -1,并将 errno 设置为 EINVAL 错误码。
2.9 alarm() 函数 — 设置告警信号(SIGALRM)传送闹钟
#include <unistd.h>
unsigned int alarm(unsigned seconds);
【函数说明】alarm 函数用来设置告警信号(SIGALRM)的定时器,调用该函数,在经过参数seconds秒数后,系统将会产生一个 SIGALRM 告警信号发送给当前的进程。如果未设置信号 SIGALARM 的处理函数,那么 alarm() 函数默认处理方式是终止进程。
【返回值】如果在之前被调用的 alarm 函数的 seconds 秒时间到期之前,再次调用了alarm 函数设置了新的闹钟,则后面定时器的设置将覆盖前面的设置,即之前设置的秒数被新的闹钟时间取代,之前的 alarm 函数将返回剩余秒数的值;如果是在 seconds 秒数到期时返回的,则返回 0。
【函数使用】alarm 函数设置的定时时间到期后,系统将会产生一个 SIGALARM 信号发送给进程,因此其一般与信号处理函数一起配合使用,Linux下的信号处理函数有 signal 和 sigaction。下面的范例我们将使用 signal 函数来处理 SIGALARM 信号。
signal() 函数
#include <signal.h>
//signal函数原型声明方式1
void (*signal(int sig, void (*func)(int)))(int);
//signal函数原型声明方式2 (推荐使用方式2的函数原型声明)
typedef void (*sighandler_t)(int); //声明一个函数类型 sighandler_t
sighandler_t signal(int signo, sighandler_t handler);
【参数说明】
sig:表示信号,它是一个整数值(1~64)。在Linux中用符号常量来表示,使用 kill -l 命令可以查看所有的信号,一共有64个。如 alarm 函数产生的告警信号为 SIGALARM 。
handler:它是一个函数指针,指向信号处理函数。当产生参数 sig 表示的信号时,会回调该信号对应的信号处理函数。
范例:
#include <stdio.h>
#include <time.h>
#include <unistd.h>
#include <signal.h>
void sig_handler(int sig)
{
if(sig == SIGALRM)
printf("receive alarm signal: %d\n", sig);
alarm(5); //每隔5秒重复产生一个SIGALRM信号
}
int main()
{
int i=0;
signal(SIGALRM, sig_handler); //注册SIGALRM信号的信号处理函数sig_handler
alarm(2); //设置2秒后产生一个SIGALRM信号
for(; ; i++)
{
printf("sleep %d ...\n", i+1);
sleep(1); //进程睡眠1秒
}
return 0;
}
运行结果:
sleep 1 ...
sleep 2 ...
receive alarm signal: 14
sleep 3 ...
sleep 4 ...
sleep 5 ...
sleep 6 ...
sleep 7 ...
receive alarm signal: 14
sleep 8 ...
sleep 9 ...
sleep 10 ...
sleep 11 ...
sleep 12 ...
receive alarm signal: 14
^C
结果分析:从运行结果可以看到,当进程运行2秒后,产生了一个SIGALRM信号,并触发了该注册信号的信号处理器,即信号处理函数 sig_handler(),输出打印语句。在sig_handler函数中又调用了alarm 函数,以后每隔5秒就会产生一个SIGALRM信号,然后回调信号处理函数。在 main() 函数中,使用了无限循环。
2.10 ftime() 函数
#include <sys/timeb.h>
int ftime(struct timeb *tp);
【函数描述】取得当前的时间,并将返回的结果保存在指针 tp 所指向的 timeb 结构的存储空间中。该函数的功能类似于 time、localtime、gettimeofday、clock_gettime 函数的功能,只是保存的时间类型不同。
time():返回的 time_t 类型
localtime:返回的是 struct tm 结构体类型
gettimeofday:返回的是 struct timeval 结构体类型
clock_gettime:返回的是 struct timespec 结构体类型
ftime:返回的是 struct timeb 结构体类型
ftime 函数取得的时间是从 Epoch(即 1970-01-01 00:00:00 +0000 (UTC)) 时刻开始到当前时刻所经过的时间,并保存在 tp 指针指向的 timeb 结构的存储空间中。
【返回值】无论成功或失败都是返回 0。
范例:
#include <stdio.h>
#include <string.h>
#include <sys/timeb.h>
#include <time.h>
int main()
{
struct timeb tb;
memset(&tb, 0, sizeof(struct timeb));
time_t now = time(NULL);
printf("time()=%d\n", now);
ftime(&tb);
printf("tb.time=%d\n", tb.time);
printf("tb.millitm=%d\n", tb.millitm);
printf("tb.timezone=%d\n", tb.timezone);
printf("tb.dstflag=%d\n", tb.dstflag);
return 0;
}
运行结果:
time()=1645962384
tb.time=1645962384
tb.millitm=170
tb.timezone=0
tb.dstflag=0
2.11 tzset() 函数 — 使用系统环境变量初始化时间转换信息
#include <time.h>
void tzset (void);
extern char *tzname[2]; //字符指针数组
extern long timezone;
extern int daylight;
【函数描述】tzset() 函数使用系统环境变量 TZ 的当前设置把值赋给三个全局变量: daylight, timezone 和 tzname。如果环境变量 TZ 没有设置,全局变量 tzname 会按照 /etc/localtime 找出最接近当地的时区。如果环境变量TZ的值为NULL,或是无法判断,则使用UTC时区。
基于TZ环境变量的值,当调用tzset()函数时把如下值赋给全局变量 daylight、timezone 和 tzname:
全局变量 说明 缺省值
daylight 如果在TZ设置中指定夏令时时区 有夏令时则为非0值;否则为0
timezone UTC和本地时间之间的时差,单位为秒 28800(28800秒等于8小时)
tzname[0] TZ环境变量的时区名称的字符串值 如果TZ未设置则为空 PST
tzname[1] 夏令时时区的字符串值; 如果TZ环境变量中忽略夏令时时区则为空PDT。在上表中daylight 和 tzname数组的缺省值对应于"PST8PDT",即太平洋标准时间(PST)和太平洋夏令时(PDT)。
tzname[0] = "PST" 表示太平洋标准时间
tzname[1] = "PDT" 表示太平洋夏令时
timezone = 28800 表示UTC和本地时间的时区差,用秒来表示,8小时即为 28800 秒。
如果从TZ环境变量忽略DST(夏令时)时区,daylight的值为0,ftime, gmtime 和 localtime 函数对于它们的DST标志返回0。
【参考链接】
linux 的时区设置函数 tzset()
全球时区大全
UTC和GMT时间
范例:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <errno.h>
int main()
{
time_t now;
//输出tzname,timezone,daylight的默认值
tzset();
printf("daylight = %d\n", daylight);
printf("timezone = %ld\n", timezone);
printf("tzname[0]=%s, tzname[1]=%s\n", tzname[0], tzname[1]);
time(&now);
printf("default time = %s\n", asctime(localtime(&now)));
if(putenv("TZ=PST8PDT") != 0) //设置太平洋标准时间和太平洋夏令时
{
printf("putenv() error: %d:%s\n", errno, strerror(errno));
return -1;
}
tzset();
printf("daylight = %d\n", daylight);
printf("timezone = %ld\n", timezone);
printf("tzname[0]=%s, tzname[1]=%s\n", tzname[0], tzname[1]);
time(&now);
printf("PST time = %s\n", asctime(localtime(&now)));
if(setenv("TZ","UTC-8", 1) != 0) //设置中国时区时间 UTC=北京时间-8(中国没有夏令时)
{
printf("putenv() error: %d:%s\n", errno, strerror(errno));
return -1;
}
tzset();
printf("daylight = %d\n", daylight);
printf("timezone = %ld\n", timezone);
printf("tzname[0]=%s, tzname[1]=%s\n", tzname[0], tzname[1]);
time(&now);
printf("China time = %s\n", asctime(localtime(&now)));
return 0;
}
运行结果:
daylight = 1
timezone = -28800
tzname[0]=CST, tzname[1]=CDT
default time = Sun Feb 27 21:45:35 2022
daylight = 1
timezone = 28800
tzname[0]=PST, tzname[1]=PDT
PST time = Sun Feb 27 05:45:35 2022
daylight = 0
timezone = -28800
tzname[0]=UTC, tzname[1]=UTC
China time = Sun Feb 27 21:45:35 2022
结果分析:
<说明> 本人 Linux 系统中并未设置 TZ 环境变量。
第一组输出中,CST 表示的是美国中部标准时间缩写,-28800秒(-8小时)表示该时区比UTC早8个小时,夏令时缩写为 CDT(美国中部夏令时),这个默认值的输出结果显然是有问题的。
第二组输出中,PST 表示的是太平洋标准时间缩写,28880秒(8小时)表示该时区比UTC晚8个小时,夏令时缩写为 PDT(太平洋夏令时)。
第三组删除中,UTC-8 表示的是中国标准时间缩写,-28800秒(-8小时)表示该时区比UTC早8个小时,中国无夏令时。
CST 时区缩写同时可以代表如下 3 个不同的时区:
Central Standard Time (USA) UTC-6:00(美国中部时间)
China Standard Time UTC+8:00(中国时间)
Cuba Standard Time UTC-4:00(古巴时间)
【备注】设置 Linux 系统的环境变量可以使用 setenv 或 putenv 函数,取消环境变量的设置可以使用 unsetenv 函数。这3个函数的函数原型如下:
#include <stdlib.h>
int setenv(const char *name, const char *value, int overwrite);
int unsetenv(const char *name);
int putenv(char *string);
三、时间日期函数的应用
3.1 获取当前日期时间字符串格式(时间粒度精确到秒)
#include <stdio.h>
#include <string.h>
#include <time.h>
void get_format_now_string(char *format, char *buf);
void get_format_time_string(time_t time, char *format, char *buf);
void get_date_string(char *buf) {
if (buf == NULL) {
return;
}
time_t now = time(NULL);
struct tm mytm={0};
struct tm* p_tm = localtime_r(&now, &mytm);
sprintf(buf, "%4d-%02d-%02d", p_tm->tm_year + 1900, p_tm->tm_mon + 1, p_tm->tm_mday);
}
void get_now_string(char *buf)
{
get_format_now_string("%4d-%02d-%02d %02d:%02d:%02d", buf);
}
void get_compact_now_string(char* buf)
{
get_format_now_string("%4d%02d%02d%02d%02d%02d", buf);
}
void get_time_string(time_t time,char* buf)
{
get_format_time_string(time,"%4d-%02d-%02d %02d:%02d:%02d", buf);
}
void get_compact_time_string(time_t time,char* buf)
{
get_format_time_string(time,"%4d%02d%02d%02d%02d%02d", buf);
}
void get_format_now_string(char* format, char* buf)
{
time_t now = time(NULL);
get_format_time_string(now,format,buf);
}
void get_format_time_string(time_t time, char* format, char *buf)
{
if (buf == NULL) {
return;
}
struct tm mytm={0};
struct tm* p_tm = localtime_r(&time,&mytm); //localtime_r是线程安全版本函数
if (p_tm == NULL) {
return;
}
sprintf(buf, format, p_tm->tm_year + 1900, p_tm->tm_mon + 1, p_tm->tm_mday,
p_tm->tm_hour, p_tm->tm_min, p_tm->tm_sec);
}
测试用例
int main()
{
char buf[255]={0};
get_date_string(buf);
printf("date_string=%s\n", buf);
get_now_string(buf);
printf("now_string=%s\n", buf);
get_compact_now_string(buf);
printf("compact_now_string=%s\n", buf);
int now = time(NULL);
get_time_string(now, buf);
printf("time_string=%s\n", buf);
get_compact_time_string(now, buf);
printf("compact_time_string=%s\n", buf);
return 0;
}
运行结果
date_string=2022-02-27
now_string=2022-02-27 17:59:33
compact_now_string=20220227175933
time_string=2022-02-27 17:59:33
compact_time_string=20220227175933
3.2 获取当前日期时间字符串格式(时间粒度精确到毫秒)
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <sys/types.h>
void get_format_milli_now_string(char* format, char* buf);
void get_format_milli_time_string(time_t time, suseconds_t usec, char* format, char* buf);
void get_milli_now_string(char* buf)
{
get_format_milli_now_string("%4d-%02d-%02d %02d:%02d:%02d.%03d", buf);
}
void get_compact_milli_now_string(char* buf)
{
get_format_milli_now_string("%4d%02d%02d%02d%02d%02d.%03d", buf);
}
void get_format_milli_now_string(char* format, char* buf)
{
struct timeval tv;
gettimeofday(&tv, NULL);
get_format_milli_time_string(tv.tv_sec, tv.tv_usec, format, buf);
}
void get_milli_time_string(time_t time, suseconds_t usec, char* buf)
{
get_format_milli_time_string(time, usec, "%4d-%02d-%02d %02d:%02d:%02d.%03d", buf);
}
void get_compact_milli_time_string(time_t time, suseconds_t usec, char* buf)
{
get_format_milli_time_string(time, usec, "%4d%02d%02d%02d%02d%02d.%03d", buf);
}
void get_format_milli_time_string(time_t time, suseconds_t usec, char* format, char* buf)
{
if(buf == NULL) {
return;
}
struct tm mytm={0};
struct tm* p_tm = localtime_r(&time, &mytm);
if (p_tm == NULL) {
return;
}
sprintf(buf, format, p_tm->tm_year + 1900, p_tm->tm_mon + 1, p_tm->tm_mday,
p_tm->tm_hour, p_tm->tm_min, p_tm->tm_sec,usec/1000);
}
测试用例
int main()
{
char buf[255]={0};
get_milli_now_string(buf);
printf("milli_now_string=%s\n", buf);
get_compact_milli_now_string(buf);
printf("compact_milli_now_string=%s\n", buf);
struct timeval tv;
gettimeofday(&tv, NULL);
get_milli_time_string(tv.tv_sec, tv.tv_usec, buf);
printf("milli_time_string=%s\n", buf);
get_compact_milli_time_string(tv.tv_sec, tv.tv_usec, buf);
printf("compact_milli_time_string=%s\n", buf);
return 0;
}
运行结果:
milli_now_string=2022-02-27 18:20:47.220
compact_milli_now_string=20220227182047.221
milli_time_string=2022-02-27 18:20:47.221
compact_milli_time_string=20220227182047.221
参考
linux下时间有关的函数和结构体
时间函数:localtime、localtime_r
Linux 时间日期函数总结
————————————————
版权声明:本文为CSDN博主「yunfan188」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/u010429831/article/details/122722187