liunx 时间函数与时间格式与字符串之间转化

我们可以认为格林威治时间就是时间协调时间（GMT=UTC）
GMT ： 格林威治时间
UTC ： 时间协调时间
1、time_t 
time_t time(time_t *t);
取得从1970年1月1日至今的秒数。

time_t类型，这本质上是一个长整数( long )，表示从1970-01-01 00:00:00到目前计时时间的秒数，timeval则精确到毫秒


2、timeval
timeval类型，这是一个结构体类型，struct timeval 头文件为 time.h
struct timeval
{
time_t tv_sec;        /* Seconds. */ //秒
suseconds_t tv_usec;  /* Microseconds. */ //微秒
};
使用：
struct timeval tv;
gettimeofday(&tv, NULL);
printf("%d\t%d\n", tv.tv_usec, tv.tv_sec);


3、timezone
struct timezone
{  
    int tz_minuteswest;     /* minutes west of Greenwich */  
    int tz_dsttime;         /* type of DST correction */  
};


4、struct tm
tm结构，这本质上是一个结构体，里面包含了各时间字段
struct tm {  
        int tm_sec;     /* seconds after the minute - [0,59] */  
        int tm_min;     /* minutes after the hour - [0,59] */  
        int tm_hour;    /* hours since midnight - [0,23] */  
        int tm_mday;    /* day of the month - [1,31] */  
        int tm_mon;     /* months since January - [0,11] */  
        int tm_year;    /* years since 1900 */  
        int tm_wday;    /* days since Sunday - [0,6] */  
        int tm_yday;    /* days since January 1 - [0,365] */  
        int tm_isdst;   /* daylight savings time flag */  
        };
其中tm_year表示从1900年到目前计时时间间隔多少年，如果是手动设置值的话，tm_isdst通常取值-1。
功能：
tm结构体包含，年、月、日，时、分、秒
使用：
time_t t_time;
    struct tm *tmp_ptr = NULL;
    time(&t_time);
    printf("t_time = %d.\n", t_time);   
    tmp_ptr = gmtime(&t_time);


    printf("after gmtime, the time is: \
            \n yday = %d \
            \n wday = %d \
            \n year = %d \
            \n mon =  %d \
            \n mday = %d \
            \n hour = %d \
            \n min =  %d \
            \n sec =  %d \
            \n isdst =%d.\n", 
            tmp_ptr->tm_yday,
            tmp_ptr->tm_wday,
            tmp_ptr->tm_year,
            tmp_ptr->tm_mon,
            tmp_ptr->tm_mday,
            tmp_ptr->tm_hour, 
            tmp_ptr->tm_min, 
            tmp_ptr->tm_sec,
            tmp_ptr->tm_isdst
            );
打印：
t_time = 1513841065.
after gmtime, the time is:             
yday = 354             
wday = 4             
year = 117             
mon =  11             
mday = 21             
hour = 7             
min =  24             
sec =  25             
isdst =0.


5、ctime/asctime
char *ctime(const time_t *timep);
将timep转换为真是世界的时间，以字符串显示，它和asctime不同就在于传入的参数形式不一样。
char *asctime(const struct tm* timeptr);
将结构中的信息转换为真实世界的时间，以字符串的形式显示。

char *ctime(const time_t *timer) 返回一个表示当地时间的字符串，当地时间是基于参数 timer。
返回的字符串格式：Thu Dec 21 13:59:57 2017
使用：
time_t curtime;
struct tm *tm_ptr = NULL;
time(&curtime);
tm_ptr = localtime(&curtime);
printf("ctime转换的当前时间 = %s", ctime(&curtime));
printf("asctime转换的当前时间 = %s", asctime(tm_ptr));
打印：
ctime转换的当前时间 = Thu Dec 21 13:59:57 2017
asctime转换的当前时间 = Thu Dec 21 13:59:57 2017




  
6、gmtime/localtime
struct tm* gmtime(const time_t *timep);
将time_t表示的时间转换为没有经过时区转换的UTC时间，是一个struct tm结构指针。
stuct tm* localtime(const time_t *timep);
和gmtime类似，但是它是经过时区转换的时间。


time_t curtime;
gmtime 函数将 curtime 转换为struct tm结构的格林威治时间，基本的意思是，gmtime转出来的是0时区的标准时间
localtime 函数将 curtime 转换为struct tm结构的本地时间，localtime是将时区考虑在内了，转出的当前时区的时间。
举个例子：
time_t t_time;
    struct tm *tmp_ptr = NULL;
    time(&t_time);
    printf("t_time = %d.\n", t_time);   
    tmp_ptr = gmtime(&t_time);


    printf("after gmtime, the time is: \
            \n yday = %d \
            \n wday = %d \
            \n year = %d \
            \n mon =  %d \
            \n mday = %d \
            \n hour = %d \
            \n min =  %d \
            \n sec =  %d \
            \n isdst =%d.\n", 
            tmp_ptr->tm_yday,
            tmp_ptr->tm_wday,
            tmp_ptr->tm_year,
            tmp_ptr->tm_mon,
            tmp_ptr->tm_mday,
            tmp_ptr->tm_hour, 
            tmp_ptr->tm_min, 
            tmp_ptr->tm_sec,
            tmp_ptr->tm_isdst
            );
    
    tmp_ptr = localtime(&t_time);


    printf("after localtime, the time is: \
            \n yday = %d \
            \n wday = %d \
            \n year = %d \
            \n mon =  %d \
            \n mday = %d \
            \n hour = %d \
            \n min =  %d \
            \n sec =  %d \
            \n isdst =%d.\n", 
            tmp_ptr->tm_yday,
            tmp_ptr->tm_wday,
            tmp_ptr->tm_year,
            tmp_ptr->tm_mon,
            tmp_ptr->tm_mday,
            tmp_ptr->tm_hour, 
            tmp_ptr->tm_min, 
            tmp_ptr->tm_sec,
            tmp_ptr->tm_isdst
            );
    return 0;
打印：
t_time = 1513841065.
after gmtime, the time is:             
yday = 354             
wday = 4             
year = 117             
mon =  11             
mday = 21             
hour = 7             
min =  24             
sec =  25             
isdst =0.
after localtime, the time is:             
yday = 354             
wday = 4             
year = 117             
mon =  11             
mday = 21             
hour = 15             
min =  24             
sec =  25             
isdst =0.


7、mktime
time_t mktime(struct tm* timeptr);
将struct tm 结构的时间转换为从1970年至今的秒数。
mktime 与 gmtime/localtime 功能相反，gmtime/localtime 将time_t转换为struct tm结构体数据，mktime将struct tm重新转换为time_t类型的UTC时间
使用例子：
time_t t_time;
    struct tm *tm_ptr = NULL;
    time(&t_time);
    printf("time_t first time value = %d.\n", t_time);


    tm_ptr = gmtime(&t_time);
    printf("time_t switch gmtime type, the time is: \
            \n yday = %d \
            \n wday = %d \
            \n year = %d \
            \n mon =  %d \
            \n mday = %d \
            \n hour = %d \
            \n min =  %d \
            \n sec =  %d \
            \n isdst =%d.\n", 
            tm_ptr->tm_yday,
            tm_ptr->tm_wday,
            tm_ptr->tm_year,
            tm_ptr->tm_mon,
            tm_ptr->tm_mday,
            tm_ptr->tm_hour, 
            tm_ptr->tm_min, 
            tm_ptr->tm_sec,
            tm_ptr->tm_isdst
            );
    
    t_time = mktime(tm_ptr); /*重新转换为time_t类型的UTC时间，这里有一个时区的转换, 时间为0区的时间, 所以一下使用的时间都为0区的时间*/   
    printf("gmtime type switch time_t second time = %d.\n", t_time); 

打印：
time_t first time value = 1513842674.
time_t switch gmtime type, the time is:             
yday = 354             
wday = 4             
year = 117             
mon =  11             
mday = 21             
hour = 7             
min =  51             
sec =  14             
isdst =0.
gmtime type switch time_t second time = 1513813874.


8、gettimeofday
int gettimeofday(struct timeval *tv, struct timezone *tz);
返回当前距离1970年的秒数和微妙数，后面的tz是时区，一般不用。
使用例子：
struct timeval time_val;
    
    gettimeofday(&time_val, NULL); //gettimeofday(&start,&tz);结果一样
    printf("时间秒.tv_sec: %d.\n",time_val.tv_sec);
    printf("时间微秒.tv_usec: %d.\n",time_val.tv_usec);
打印：
时间秒.tv_sec:1513843633
时间微秒.tv_usec:689374

9、difftime
double difftime(time_t time1, time_t time2);
返回两个时间相差的秒数
使用例子：
//获得时间差
    time_t t_start;
    time_t t_end;
    time(&t_start);
    sleep(5);
    time(&t_end);
    printf("间隔时间= %f.\n", difftime(t_end, t_start));
打印：
间隔时间= 5.000000.


10、strftime
size_t strftime( char *strDest, size_t maxsize, const char *format, const struct tm *timeptr);
使用strftime（）函数将时间格式化为我们想要的格式。
(
%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 时区名称，如果不能得到时区名称则返回空字符。
%% 百分号
)
使用例子：
time_t t_time;
    char buf[128];
    struct tm* tm_ptr = NULL;
    time(&t_time);
    tm_ptr = localtime(&t_time);
    //2017-12-21 18:53:58
    strftime(buf, 64, "%Y-%m-%d %H:%M:%S", tm_ptr);
    strftime(buf, 64, "%Y-%m-%d --- %H:%M:%S", tm_ptr);
    printf("formatTimeString = %s.\n", buf);
打印：
formatTimeString = 2017-12-21 18:53:58.
formatTimeString = 2017-12-21 --- 18:54:46.


11、strptime
功能和 strftime 功能相反， 将字符串格式化为一个tm结构。
size_t strftime(char *s,size_t maxsize,char *format,const struct tm *timeptr);
使用例子：
char buf[] = "2017-12-21 --- 18:54:46";
    struct tm tm_ptr;
    //2017-12-21 18:53:58
    strptime(buf, "%Y-%m-%d --- %H:%M:%S", &tm_ptr);
    printf("----strptime-----, the time is: \
            \n yday = %d \
            \n wday = %d \
            \n year = %d \
            \n mon =  %d \
            \n mday = %d \
            \n hour = %d \
            \n min =  %d \
            \n sec =  %d.\n", 
            tm_ptr.tm_yday,
            tm_ptr.tm_wday,
            tm_ptr.tm_year,
            tm_ptr.tm_mon,
            tm_ptr.tm_mday,
            tm_ptr.tm_hour, 
            tm_ptr.tm_min, 
            tm_ptr.tm_sec
          );
打印：
----strptime-----, the time is:             
yday = 354             
wday = 4             
year = 117             
mon =  11             
mday = 21             
hour = 18             
min =  54             
sec =  46.