C语言 time.h 时间函数库

time.h 头文件定义了四个变量类型、两个宏和各种操作日期和时间的函数。
1	size_t   是无符号整数类型(unsigned int)，它是 sizeof 关键字的结果。
2	clock_t  这是一个适合存储处理器时间的类型。
3	time_t is 这是一个适合存储日历时间类型。
4	struct tm 这是一个用来保存时间和日期的结构


下面是头文件 time.h 中定义的宏：
1	NULL  这个宏是一个空指针常量的值。
2	CLOCKS_PER_SEC  这个宏表示每秒的处理器时钟个数


tm 结构的定义如下：
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 到 11		*/
   int tm_year;        /* 自 1900 年起的年数		*/
   int tm_wday;        /* 一周中的第几天，范围从 0 到 6	*/
   int tm_yday;        /* 一年中的第几天，范围从 0 到 365	*/
   int tm_isdst;       /* 夏令时				*/
}

1.asctime(struct tm)
char *asctime(const struct tm *timeptr) 返回一个指向字符串的指针
timeptr 是指向 tm 结构的指针，包含了分解为如下各部分的日历时间：


#include <stdio.h>
#include <string.h>
#include <time.h>


int main()
{
   struct tm t;


   t.tm_sec    = 10;  // 秒
   t.tm_min    = 49;  // 分
   t.tm_hour   = 10;   // 时
   t.tm_mday   = 21;  // 日
   t.tm_mon    = 10;   // 月
   t.tm_year   = 116;  // 年
   t.tm_wday   = 5;   //星期        


   printf("%s",asctime(&t));
   return 0;
}
打印结果:
Fri Nov 21 10:49:10 2016

2.clock_t clock(void)
clock_t clock(void) 返回程序执行起（一般为程序的开头），处理器时钟所使用的时间。
为了获取 CPU 所使用的秒数，您需要除以 CLOCKS_PER_SEC。
在 32 位系统中，CLOCKS_PER_SEC 等于 1000000  该函数大约每 72 分钟会返回相同的值
这个宏在Windows平台下是1000，而到了Linux平台下就是 1000000


#include <time.h>
#include <stdio.h>


int main()
{
   clock_t start_t, end_t, total_t;
   int i;
   
   start_t = clock();
   printf("程序启动，start_t = %ld\n", start_t);
   int j = 0;
   printf("开始一个大循环，start_t = %ld\n", start_t);
   for(i=0; i< 30000; i++)
   {
	for(j=0; j< 10000; j++)
	{
	}
   }
   end_t = clock();
   printf("大循环结束，end_t = %ld\n", end_t);
   printf("CLOCKS_PER_SEC =  %d\n", CLOCKS_PER_SEC);
   total_t = end_t - start_t;
   printf("total_t = %ld\n", total_t);
   printf("CPU 占用的总时间：%lf\n", (total_t*0.1*10)/CLOCKS_PER_SEC);   // (total_t*0.1*10)  使得整数类型转为小数类型
   printf("程序退出...\n");


   return 0;
}
打印结果:
程序启动，start_t = 0
开始一个大循环，start_t = 0
大循环结束，end_t = 661
CLOCKS_PER_SEC =  1000
total_t = 661
CPU 占用的总时间：0.661000
程序退出...

3. char *ctime(const time_t *timer)
char *ctime(const time_t *timer) 返回一个表示当地时间的字符串，当地时间是基于参数 timer
timer -- 这是指向 time_t 对象的指针，该对象包含了一个日历时间
返回的字符串格式如下： 
Www Mmm dd hh:mm:ss yyyy 其中，Www 表示星期几，Mmm 是以字母表示的月份，dd 表示一月中的第几天，hh:mm:ss 表示时间，yyyy 表示年份。
该函数返回一个 C 字符串，该字符串包含了可读格式的日期和时间信息


#include <stdio.h>
#include <time.h>


int main ()
{
   time_t curtime;


   time(&curtime);  // 通过time() 函数使得参数 time_t得到数值


   printf("当前时间 = %s", ctime(&curtime));


   return 0;
}
打印结果:
当前时间 = Fri Oct 21 11:50:17 2016

4. double difftime(time_t time1, time_t time2) 
double difftime(time_t time1, time_t time2) 返回 time1 和 time2 之间相差的秒数 (time1 - time2)
这两个时间是在日历时间中指定的，表示了自纪元 Epoch（协调世界时 UTC：1970-01-01 00:00:00）起经过的时间
time1 -- 这是表示结束时间的 time_t 对象。
time2 -- 这是表示开始时间的 time_t 对象。
返回值 : 该函数返回以双精度浮点型 double 值表示的两个时间之间相差的秒数 (time2 - time1)。


#include <stdio.h>
#include <time.h>
#include <unistd.h>


int main ()
{
   time_t start_t, end_t;
   double diff_t;


   printf("程序启动...\n");
   time(&start_t);


   printf("休眠 6 秒...\n");
   sleep(6);


   time(&end_t);
   diff_t = difftime(end_t, start_t);


   printf("相差时间 = %f\n", diff_t);
   printf("程序退出...\n");


   return 0;
}
打印结果:
程序启动...
休眠 6 秒...
相差时间 = 6.000000
程序退出...

5.gmtime(const time_t *timer)    time_t--->tm的 UTC时区类型
struct tm *gmtime(const time_t *timer) 使用timer的值来填充tm结构并用协调世界时UTC也被称为格林尼治标准时间GMT表示
timeptr -- 这是指向表示日历时间的 time_t 值的指针。
tm 是time.h 定义的结构体


#include <stdio.h>
#include <time.h>


#define BST (+1)       // 伦敦时区  东1
#define CCT (+8)       // 北京时区  东8


int main ()
{


   time_t rawtime;
   struct tm *info;


   time(&rawtime);
   /* 获取 GMT 时间 */
   info = gmtime(&rawtime );  //根据当前的 time_t  获得对应的结构体 tm
   
   printf("当前的世界时钟：\n");
   printf("伦敦：%2d:%02d\n", (info->tm_hour+BST)%24, info->tm_min);    // 时   分
   printf("中国：%2d:%02d\n", (info->tm_hour+CCT)%24, info->tm_min);    // 时   分


   return 0;
}
打印结果:
当前的世界时钟：
伦敦： 5:07
中国：12:07

6.localtime(const time_t *timer)    time_t--->tm本地时区类型
struct tm *localtime(const time_t *timer) 使用timer的值来填充tm结构。timer的值被分解为tm结构  并用本地时区表示。
timer -- 这是指向表示日历时间的 time_t 值的指针。


#include <stdio.h>
#include <time.h>


int main ()
{
   time_t rawtime;
   struct tm *info;
   char buffer[80];


   time( &rawtime );


   info = localtime( &rawtime ); // 本地时区 填充 tm结构体
   printf("当前的本地时间和日期：%s", asctime(info));


   return 0;
}
打印结果:
当前的本地时间和日期：Fri Oct 21 12:09:31 2016

7.strftime(char *str, size_t maxsize, const char *format, const struct tm *timeptr) 
size_t strftime(char *str, size_t maxsize, const char *format, const struct tm *timeptr) 
根据 format 中定义的格式化规则，格式化结构 timeptr 表示的时间，并把它存储在 str 中
str -- 这是指向目标数组的指针，用来复制产生的 C 字符串。
maxsize -- 这是被复制到 str 的最大字符数。
format -- 这是 C 字符串，包含了普通字符和特殊格式说明符的任何组合。这些格式说明符由函数替换为表示 tm 中所指定时间的相对应值。格式说明符是：
timeptr -- 这是指向 tm 结构的指针，该结构包含了一个呗分解为以下各部分的日历时间


如果产生的 C 字符串小于 size 个字符（包括空结束字符），则会返回复制到 str 中的字符总数（不包括空结束字符），否则返回零




%a	缩写的星期几名称	Sun
%A	完整的星期几名称	Sunday
%b	缩写的月份名称	Mar
%B	完整的月份名称	March
%c	日期和时间表示法	Sun Aug 19 02:56:02 2012
%d	一月中的第几天（01-31）	19
%H	24 小时格式的小时（00-23）	14
%I	12 小时格式的小时（01-12）	05
%j	一年中的第几天（001-366）	231
%m	十进制数表示的月份（01-12）	08
%M	分（00-59）	55
%p	AM 或 PM 名称	PM
%S	秒（00-61）	02
%U	一年中的第几周，以第一个星期日作为第一周的第一天（00-53）	33
%w	十进制数表示的星期几，星期日表示为 0（0-6）	4
%W	一年中的第几周，以第一个星期一作为第一周的第一天（00-53）	34
%x	日期表示法	08/19/12
%X	时间表示法	02:50:06
%y	年份，最后两个数字（00-99）	01
%Y	年份	2012
%Z	时区的名称或缩写	CDT
%%	一个 % 符号	%




#include <stdio.h>
#include <time.h>


int main ()
{
   time_t rawtime;
   struct tm *info;
   char buffer[80];


   time( &rawtime );


   info = localtime( &rawtime );


   strftime(buffer,80,"%x - %I:%M%p", info);
   printf("格式化的日期 & 时间 : |%s|\n", buffer );
  
   return 0;
}
打印结果:
格式化的日期 & 时间 : |10/21/16 - 12:20PM|

8.mktime(struct tm *timeptr)     tm类型--->time_t                   time_t是一个毫秒数
time_t mktime(struct tm *timeptr) 把 timeptr 所指向的结构转换为一个依据本地时区的 time_t 值
该函数返回一个 time_t 值，该值对应于以参数传递的日历时间。如果发生错误，则返回 -1 值。


#include <stdio.h>
#include <time.h>


int main ()
{
   int ret;
   struct tm info;
   char buffer[80];


   info.tm_year = 116;
   info.tm_mon = 9;
   info.tm_mday = 21;
   info.tm_hour = 12;
   info.tm_min = 10;
   info.tm_sec = 55;
   info.tm_isdst = -1;


   ret = mktime(&info);
   if( ret == -1 )
   {
       printf("错误：不能使用 mktime 转换时间。\n");
   }
   else
   {
       printf("ret = %d\n",ret);
      strftime(buffer, sizeof(buffer), "%c", &info );
      printf(buffer);
   }


   return 0;
}
打印结果:
ret = 1477023055
10/21/16 12:10:55

9. time_t time(time_t *seconds) 
 返回自纪元 Epoch（1970-01-01 00:00:00 UTC）起经过的时间，以秒为单位。
 如果 seconds 不为空，则返回值也存储在变量 seconds 中
time_t time(time_t *t)
 
#include <stdio.h>
#include <time.h>


int main ()
{
  time_t seconds;


  seconds = time(NULL);
  printf("自 1970-01-01 起的小时数 = %ld\n", seconds/3600);
  
  return 0;
}
打印结果:
自 1970-01-01 起的小时数 = 410284