精华内容
下载资源
问答
  • 为什么tm_year是从1900开始而不是1970

    千次阅读 2019-04-04 22:33:42
    Why is the tm_year member in struct tm relative to 1900 rather than 1970 in C on macosx? 对该问题回答的原文: The struct tm is designed for parsing, displaying, and manipulating human-r...

    stackoverflow上找到了答案:

    Why is the tm_year member in struct tm relative to 1900 rather than 1970 in C on macosx?

    对该问题回答的原文:


    The struct tm is designed for parsing, displaying, and manipulating human-readable dates. When it was created, dates were commonly written and even stored without the “19” part of the year number and the Y2K problem was around 25 years away. So the convenience of making tm_year directly printable as two digits, by making it relative to 1900, apparently seemed reasonable at the time.


    大概意思就是说:


    struct tm用于解析,显示和操作人类可读的日期。 在创建日期时,日期通常是在年份去掉19”部分的情况下编写与存储,并且距离Y2K问题大约还有25年。 因此,相对于1900,将tm_year直接打印成两位数就十分便利,显然在当时是合理的。


    展开全文
  • c/c++ time->time_t->struct tm 中的tm_year 是从1900年算起的时间
    c/c++  time->time_t->struct tm 中的tm_year 是从1900年算起的时间
    展开全文
  • c++ 时间类型详解(time_t和tm)

    千次阅读 2016-01-13 20:21:35
    , 1900 + p->tm_year, 1 + p->tm_mon, p->tm_mday);   printf( "%s %d:%d:%d\n" , wday[p->tm_wday], p->tm_hour,   p->tm_min, p->tm_sec);    return  0;  }  编译并运行:...

    原文:http://blog.csdn.net/love_gaohz/article/details/6637625

    Unix时间戳(Unix timestamp),或称Unix时间(Unix time)、POSIX时间(POSIX time),一种时间表示方式,定义为从格林威治时间1970年01月01日00时00分00秒起至现在的总秒数。Unix时间戳不仅被使用在Unix 系统、类Unix系统中,也在许多其他操作系统中被广告采用。

    目前相当一部分操作系统使用32位二进制数字表示时间。此类系统的Unix时间戳最多可以使用到格林威治时间2038年01月19日03时14分07秒(二进制:01111111 11111111 11111111 11111111)。其后一秒,二进制数字会变为10000000 00000000 00000000 00000000,发生溢出错误,造成系统将时间误解为1901年12月13日20时45分52秒。这很可能会引起软件故障,甚至系统瘫痪。使用64位二进制数字表示时间的系统(最多可以使用到格林威治时间292,277,026,596年12月04日15时30分08秒)则基本不会遇到这类溢出问题。

    首先我们了解一下时间的相关概念,以及之间的区别,需要了解的时间概念有:
    本地时间(locale time)
    格林威治时间(Greenwich Mean Time GMT
    时间协调时间 (Universal Time Coordinated UTC


      本地时间,显而易见不用解释了
      先看看时间的标准:
    (1)世界时 
    世界时是最早的时间标准。在1884年,国际上将1s确定为全年内每日平均长度的1/8.64×104。以此标准形成的时间系统,称为世界是,即UT1。1972年国际上开始使用国际原子时标,从那以后,经过格林威治老天文台本初子午线的时间便被称为世界时,即UT2,或称格林威治时间(GMT),是对地球转速周期性差异进行校正后的世界时。 
    (2)原子时 
    1967年,人们利用铯原子振荡周期极为规律的特性,研制出了高精度的原子时钟,将铯原子能级跃迁辐射9192631770周所经历的时间定为1s。现在用的时间就是1971年10月定义的国际原子时,是通过世界上大约200多台原子钟进行对比后,再由国际度量衡局时间所进行数据处理,得出的统一的原子时,简称TAI。 
    (3)世界协调时 
    世界协调时是以地球自转为基础的时间标准。由于地球自转速度并不均匀,并非每天都是精确的86400原子s,因而导致了自转时间与世界时之间存在18个月有1s的误差。为纠正这种误差,国际地球自转研究所根据地球自转的实际情况对格林威治时间进行增减闰s的调整,与国际度量衡局时间所联合向全世界发布标准时间,这就是所谓的世界协调时(UTC:CoordinatdeUniversalTime)。UTC的表示方式为:年(y)、月(m)、日(d)、时(h)、分(min)、秒(s),均用数字表示。

      
    GPS 系统中有两种时间区分,一为UTC,另一为LT(地方时)两者的区别为时区不同,UTC就是0时区的时间,地方时为本地时间,如北京为早上八点(东八区),UTC时间就为零点,时间比北京时晚八小时,以此计算即可
      通过上面的了解,我们可以认为格林威治时间就是世界协调时间(GMT=UTC),格林威治时间和UTC时间均用秒数来计算的。

       而在我们平时工作当中看到的计算机日志里面写的时间大多数是用UTC时间来计算的,那么我们该怎么将UTC时间转化为本地时间便于查看日志,那么在作程序开发时又该怎么将本地时间转化为UTC时间呢?
       下面就介绍一个简单而使用的工具,就是使用linux/unix命令date来进行本地时间和local时间的转化。
       大家都知道,在计算机中看到的utc时间都是从(1970年01月01日 0:00:00)开始计算秒数的。所看到的UTC时间那就是从1970年这个时间点起到具体时间共有多少秒。

    我们在编程中可能会经常用到时间,比如取得系统的时间(获取系统的年、月、日、时、分、秒,星期等),或者是隔一段时间去做某事,那么我们就用到一些时间函数。


    linux下存储时间常见的有两种存储方式,一个是从1970年到现在经过了多少秒一个是用一个结构来分别存储年月日时分秒的
    time_t 这种类型就是用来存储从1970年到现在经过了多少秒,要想更精确一点,可以用结构struct timeval,它精确到微妙。
    struct timeval
    {
        long tv_sec; /*秒*/
        long tv_usec; /*微秒*/

    };


    而直接存储年月日的是一个结构:
    struct tm
    {
        int tm_sec;  /*秒,正常范围0-59, 但允许至61*/
        int tm_min;  /*分钟,0-59*/
        int tm_hour; /*小时, 0-23*/
        int tm_mday; /*日,即一个月中的第几天,1-31*/
        int tm_mon;  /*月, 从一月算起,0-11*/  1+p->tm_mon;
        int tm_year;  /*年, 从1900至今已经多少年*/  1900+ p->tm_year;
        int tm_wday; /*星期,一周中的第几天, 从星期日算起,0-6*/
        int tm_yday; /*从今年1月1日到目前的天数,范围0-365*/
        int tm_isdst; /*日光节约时间的旗标*/
    };

    需要特别注意的是,年份是从1900年起至今多少年,而不是直接存储如2011年,月份从0开始的,0表示一月,星期也是从0开始的, 0表示星期日,1表示星期一。


    下面介绍一下我们常用的时间函数:
    #include <time.h>
    char *asctime(const struct tm* timeptr);

    将结构中的信息转换为真实世界的时间,以字符串的形式显示


    char *ctime(const time_t* timep);

    将timep转换为真是世界的时间,以字符串显示,它和asctime不同就在于传入的参数形式不一样


    double difftime(time_t time1, time_t time2);

    返回两个时间相差的秒数


    int gettimeofday(struct timeval* tv,struct timezone* tz);

    返回当前距离1970年的秒数和微妙数,后面的tz是时区,一般不用


    struct tm* gmtime(const time_t* timep);

    将time_t表示的时间转换为没有经过时区转换的UTC时间,是一个struct tm结构指针


    struct tm* localtime(const time_t* timep);

    和gmtime类似,但是它是经过时区转换的时间。


    time_t mktime(struct tm* timeptr);

    将struct tm 结构的时间转换为从1970年至今的秒数


    time_t time(time_t* t);

    取得从1970年1月1日至今的秒数。


    上面是简单的介绍,下面通过实战来看看这些函数的用法:
    下载: gettime1.c
    [cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
    1. /*gettime1.c*/  
    2. #include <time.h>  
    3.   
    4. int main()  
    5. {  
    6.     time_t timep;  
    7.      
    8.     time(&timep); /*获取time_t类型的当前时间*/  
    9.     /*用gmtime将time_t类型的时间转换为struct tm类型的时间,按没有经过时区转换的UTC时间 
    10.       然后再用asctime转换为我们常见的格式 Fri Jan 11 17:25:24 2008 
    11.     */  
    12.     printf("%s", asctime(gmtime(&timep)));  
    13.     return 0;  
    14. }  
    编译并运行:
    $gcc -o gettime1 gettime1.c
    $./gettime1

    Fri Jan 11 17:04:08 2008


    下面是直接把time_t类型的转换为我们常见的格式:

    下载: gettime2.c
    [cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
    1. /* gettime2.c*/  
    2. #include <time.h>  
    3.   
    4. int main()  
    5. {  
    6.     time_t timep;  
    7.      
    8.     time(&timep); /*获取time_t类型当前时间*/     
    9.     /*转换为常见的字符串:Fri Jan 11 17:04:08 2008*/  
    10.     printf("%s", ctime(&timep));  
    11.     return 0;  
    12. }  
    编译并运行:
    $gcc -o gettime2 gettime2.c
    $./gettime2
    Sat Jan 12 01:25:29 2008
    我看了一本书上面说的这两个例子如果先后执行的话,两个的结果除了秒上有差别之外(执行程序需要时间),应该是一样的,可是我这里执行却发现差了很长时间按,一个是周五,一个是周六,后来我用 date 命令执行了一遍
    $date
    六 1月 12 01:25:19 CST 2008

    我发现date和gettime2比较一致, 我估计可能gettime1并没有经过时区的转换,它们是有差别的。

    (我(非原作者)执行gettime1和gettime2的结果分别是Sun Mar 02 06:53:58 2014    Sun Mar 02 14:53:58 2014,第二个和我本地计算机的时间一样,应该gettime1是没有经过时区的转换,gettime2是获得本地的时间).


    下载: gettime3.c

    [cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
    1. /*gettime3.c */  
    2. #include <time.h>  
    3.   
    4. int main()  
    5. {  
    6.     char *wday[] = {"Sun""Mon""Tue""Wed""Thu""Fri""Sat"};  
    7.     time_t timep;  
    8.     struct tm *p;  
    9.      
    10.     time(&timep); /*获得time_t结构的时间,UTC时间*/  
    11.     p = gmtime(&timep); /*转换为struct tm结构的UTC时间*/  
    12.     printf("%d/%d/%d ", 1900 + p->tm_year, 1 + p->tm_mon, p->tm_mday);  
    13.     printf("%s %d:%d:%d\n", wday[p->tm_wday], p->tm_hour,  
    14.         p->tm_min, p->tm_sec);  
    15.     return 0;  
    16. }  
    编译并运行:
    $gcc -o gettime3 gettime3.c
    $./gettime3
    2008/1/11 Fri 17:42:54
    从这个时间结果上来看,它和gettime1保持一致。


    下载: gettime4.c

    [cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
    1. /*gettime4.c*/  
    2. #include <time.h>  
    3.   
    4. int main()  
    5. {  
    6.     char *wday[] = {"Sun""Mon""Tue""Wed""Thu""Fri""Sat"};  
    7.     time_t timep;  
    8.     struct tm *p;  
    9.      
    10.     time(&timep); /*获得time_t结构的时间,UTC时间*/  
    11.     p = localtime(&timep); /*转换为struct tm结构的当地时间*/  
    12.     printf("%d/%d/%d ", 1900 + p->tm_year, 1 + p->tm_mon, p->tm_mday);  
    13.     printf("%s %d:%d:%d\n", wday[p->tm_wday], p->tm_hour, p->tm_min, p->tm_sec);  
    14.     return 0;  
    15. }  
    编译并运行:
    $gcc -o gettime4 gettime4.c
    $./gettime4
    2008/1/12 Sat 1:49:29
    从上面的结果我们可以这样说:

    time, gmtime, asctime 所表示的时间都是UTC时间,只是数据类型不一样,

    localtime, ctime 所表示的时间都是经过时区转换后的时间,它和你用系统命令date所表示的CST时间应该保持一致


    下载: gettime5.c

    [cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
    1. /*gettime5.c*/  
    2. #include <time.h>  
    3.   
    4. int main()  
    5. {  
    6.     time_t timep;  
    7.     struct tm *p;  
    8.   
    9.     time(&timep); /*当前time_t类型UTC时间*/  
    10.     printf("time():%d\n",timep);  
    11.     p = localtime(&timep); /*转换为本地的tm结构的时间按*/  
    12.     timep = mktime(p); /*重新转换为time_t类型的UTC时间,这里有一个时区的转换*/   
    13.     //by lizp 错误,没有时区转换, 将struct tm 结构的时间转换为从1970年至p的秒数  
    14.     printf("time()->localtime()->mktime(): %d\n", timep);  
    15.     return 0;  
    16. }  
    编译并运行:
    $gcc -o gettime5 gettime5.c
    $./gettime5
    time():1200074913
    time()->localtime()->mktime(): 1200074913

    这里面把UTC时间按转换为本地时间,然后再把本地时间转换为UTC时间,它们转换的结果保持一致。


    下载: gettime6.c

    [cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
    1. /*gettime6.c */  
    2. #include <time.h>  
    3.   
    4. int main()  
    5. {  
    6.     time_t timep;  
    7.     struct tm *p;  
    8.   
    9.     time(&timep);  /*得到time_t类型的UTC时间*/  
    10.     printf("time():%d\n",timep);  
    11.     p = gmtime(&timep); /*得到tm结构的UTC时间*/  
    12.     timep = mktime(p); /*转换,这里会有时区的转换*/ //by lizp 错误,没有时区转换, 将struct tm 结构的时间转换为从1970年至p的秒数  
    13.     printf("time()->gmtime()->mktime(): %d\n", timep);  
    14.     return 0;  
    15. }  
    编译并运行:
    $gcc -o gettime6 gettime6.c
    $./gettime6
    time():1200075192
    time()->gmtime()->mktime(): 1200046392

    从这里面我们可以看出,转换后时间不一致了,计算一下,整整差了8个小时( (1200075192-1200046392)/3600 = 8),说明 mktime会把本地时间转换为UTC时间 ,这里面本来就是UTC时间,于是再弄个时区转换,结果差了8个小时,用的时候应该注意。

    strftime() 函数将时间格式化
    我们可以使用strftime()函数将时间格式化为我们想要的格式。它的原型如下:
    size_t strftime(
         char *strDest,
         size_t maxsize,
         const char *format,
         const struct tm *timeptr
    );
    我们可以根据format指向字符串中格式命令把timeptr中保存的时间信息放在strDest指向的字符串中,最多向strDest中存放maxsize个字符。该函数返回向strDest指向的字符串中放置的字符数。
    函数strftime()的操作有些类似于sprintf():识别以百分号(%)开始的格式命令集合,格式化输出结果放在一个字符串中。格式化命令说明串 strDest中各种日期和时间信息的确切表示方法。格式串中的其他字符原样放进串中。格式命令列在下面,它们是区分大小写的。
    %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 时区名称,如果不能得到时区名称则返回空字符。
    %% 百分号
    如果想显示现在是几点了,并以12小时制显示,就象下面这段程序:
    [cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
    1. #include "time.h"  
    2. #include "stdio.h"  
    3. int main(void)  
    4. {  
    5.     struct tm *ptr;  
    6.     time_t lt;  
    7.     char str[80];  
    8.     lt=time(NULL);  
    9.     ptr=localtime(&lt);  
    10.     strftime(str,100,"It is now %I %p",ptr);  
    11.     printf(str);  
    12.     return 0;  
    13. }  
    其运行结果为:

    It is now 4PM


    而下面的程序则显示当前的完整日期:

    [cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
    1. #include<stdio.h>  
    2. #include<string.h>  
    3. #include<time.h>  
    4. int main( void )  
    5. {  
    6.     struct tm *newtime;  
    7.     char tmpbuf[128];  
    8.     time_t lt1;  
    9.      
    10. time( &lt1 );  
    11.     newtime=localtime(&lt1);  
    12.      
    13. strftime( tmpbuf, 128, "Today is %A, the %d day of %B in the year %Y.\n", newtime);  
    14.     printf(tmpbuf);  
    15.   
    16. return 0;  
    17. }  

    其运行结果为:

    Today is Sunday, the 02 day of March in the year 2014.

    展开全文
  • CRT中的时间(time_t和tm)

    千次阅读 2011-10-08 22:30:26
    printf("Local Time(YYYY-MM-DD HH:MM:SS): %d-%d-%d %d:%d:%d/n", tmLocal.tm_year + 1900, tmLocal.tm_mon, tmLocal.tm_mday, tmLocal.tm_hour, tmLocal.tm_min, tmLocal.tm_sec); //Get UTC time ...
     时间处理时实际项目中经常碰到的问题,这里介绍最常用的时间处理函数。 
    

        首先介绍基本的时间概念。时间一般分为两种,一种是本地时间(Local Time),一种是协调世界时间(Coordinated Universal Time ,UTC),也就是传说中的格林威治时间。本地时间与UTC时间之间的差即为时差,比如,北京时间(东八区)比UTC时间早8个小时。

        C运行库中处理时间的函数主要是这四个:

        

    1. time_t time(  
    2.             time_t *timer);  
    3.    

        time_t类型为32位或64位整型,具体类型由编译系统决定。此函数用来获得从1970年1月1日子夜(这个时刻在不同的CRT实现中可能会不一样)到当前时刻以来所流逝的时间,以秒为单位。这个时间差叫做日历时间(Calendar Time )。

        这是当然让我困惑的地方:这个特殊的时刻——1970年1月1日零时零分零秒——是指本地时间呢,还是UTC时间呢?我认为是本地时间,也就是各个时区自己的1970年1月1日零时零分零秒。可以设想这样一种情况,如果全球24时区各有一台电脑,都依次在自己所在时区的本地时间1970年1月1日零时1分零秒调用time函数,那么返回值都是60。注意,这里是依次调用(事实上是每隔1小时),而不是想象中的同时调用,这是因为相邻时区的同一本地时间,总是相差1小时。

        当然,time_t型的时间方便计算机处理,但普通用户无法理解这种数字。所以我们通常需要将time_t型时间转换成我们平常所见的年月日形式。CRT中为此定义了tm结构。

       

    1. struct tm {  
    2.     int tm_sec;     /* seconds after the minute - [0,59] */  
    3.     int tm_min;     /* minutes after the hour - [0,59] */  
    4.     int tm_hour;    /* hours since midnight - [0,23] */  
    5.     int tm_mday;    /* day of the month - [1,31] */  
    6.     int tm_mon;     /* months since January - [0,11] */  
    7.     int tm_year;    /* years since 1900 */  
    8.     int tm_wday;    /* days since Sunday - [0,6] */  
    9.     int tm_yday;    /* days since January 1 - [0,365] */  
    10.     int tm_isdst;   /* daylight savings time flag */  
    11. };  

        注释中已详细解释了各个字段的用法。显然这个结构中的字段对用户更有意义。我们通常用localtime_s函数将time_t时间转换为tm时间。

       

    1. errno_t localtime_s(  
    2.                     struct tm* _tm,  
    3.                     const time_t *time);  

        其中第二个参数为传入的time_t时间,第一个参数为返回的tm时间。由函数名可看出,返回的tm时间表示的是本地时间。当然,我们有时候也需要获得对应的UTC时间,这时我们需要gmtime函数。

       

    1. errno_t gmtime_s(  
    2.                  struct tm* _tm,  
    3.                  const time_t* time);  

        后面我们会看到两者的区别。

        我们知道了如何将time_t时间转换为tm时间。同样,我们会需要将tm表示的时间转换为time_t时间。这时我们需要mktime函数。

       

    1. time_t mktime(  
    2.               struct tm *timeptr);  

        此函数返回从"特殊时刻"到参数表示的时刻之间流逝的日历时间。另外还有个很好用的特性,就是它能修正传进来的tm结构中各字段的取值范围。比如,如果你将tm.tm_mon设为1,tm.tm_day设为33,然后以其为参数调用mktime函数,此函数会将tm.tm_mon修正为2,tm.tm_day修正为2。具体用法参照MSDN。

        我们来分析下面示例代码:

       

    1. #include <stdlib.h>   
    2. #include <stdio.h>   
    3. #include <time.h>   
    4.   
    5.   
    6. int main()  
    7. {  
    8.     struct tm   tmLocal, tmUTC;  
    9.     time_t  tNow;  
    10.     //Get current calendar time   
    11.     time(&tNow);  
    12.     printf("Time Now from time(): %llu/n", tNow);     
    13.     //Get current local time   
    14.     localtime_s(&tmLocal, &tNow);   
    15.     printf("Local Time(YYYY-MM-DD HH:MM:SS): %d-%d-%d %d:%d:%d/n", tmLocal.tm_year + 1900, tmLocal.tm_mon,  
    16.         tmLocal.tm_mday, tmLocal.tm_hour, tmLocal.tm_min, tmLocal.tm_sec);  
    17.     //Get UTC time corresponding to current local time, and tmLocal.tm_hour - tmUTC.tm_hour = 8  
    18.     gmtime_s(&tmUTC, &tNow);      
    19.     printf("UTC Time  (YYYY-MM-DD HH:MM:SS): %d-%d-%d %d:%d:%d/n", tmUTC.tm_year + 1900, tmUTC.tm_mon,  
    20.         tmUTC.tm_mday, tmUTC.tm_hour, tmUTC.tm_min, tmUTC.tm_sec);  
    21.     //convert tmLocal to calendar time  
    22.     tNow = mktime(&tmLocal);      
    23.     printf("Time Now from mktime(): %llu/n", tNow);  
    24.   
    25.     return EXIT_SUCCESS;  
    26. }  

        输出结果如下:

        输出结果

        上面代码中,11行time函数获得从"特殊时刻"到当前时刻的日历时间,如输出结果中的第一行显示的1267192581秒。

        14行localtime_s函数将日历时间转换为本地tm时间,如输出结果第二行。

        18行gmtime_s函数将将日历时间转换为对应的UTC的tm时间,如输出结果第三行显示。很容易看出,第二,三行输出的时间相差8小时,因为我在东八区。如果你修改自己电脑的时区(在控制面板的Date and Time中修改),再运行此程序,比较两次的运行结果,你就可以更好的理解了。

        22行mktime函数将tm时间转换为日历时间,输出结果中第四行显示的结果与第一行一样,这是必须的。。。

    展开全文
  • tm->tm_mday = day + 1

    千次阅读 2015-07-29 09:28:10
    在STM32的RTC程序中, tm->tm_mday = day + 1; 这个日期为什么要加一呢2012-09-01 23:17xieshun1988 分
  • python基础(time时间模块)

    千次阅读 2019-03-05 18:41:16
    (tm_year=2017, tm_mon=7, tm_mday=4, tm_hour=9, tm_min=4, tm_sec=21, tm_wday=1, tm_yday=185, tm_isdst=0) 格式:(年,月,日,时,分,秒,周几,一年中的第几天,是否是夏令时)  Python日期元组中的...
  • time_t iso_year_week_day_tm (int year, int week, int day, int hour, int min, int sec, struct tm* tm); time_t iso_year_week_day_tm (int year, int week, int day, struct tm* tm); 从ISO-8601的年...
  • time(tm_year=2021, tm_mon=1, tm_mday=17, tm_hour=15, tm_min=16, tm_sec=30, tm_wday=6, tm_yday=17, tm_isdst=0) >>> >>>time.localtime(0) time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=8, tm...
  • 搜索查询日期间隔的方法的时候,找到tm类。这个类可以实现简单的日期计算,比如设置好年月日就能从tm_wday知道是星期几。 #include #include #include #include #include using std::memset; using std::tm; ...
  • C语言中time函数和localtime获取系统时间和日期

    万次阅读 多人点赞 2018-05-18 09:51:47
    C语言中time函数和localtime获取系统时间和日期       可以通过 time()函数来获得计算机系统当前...tm_now->tm_year+1900, tm_now->tm_mon+1, tm_now->tm_mday, tm_now->tm_hour, tm_now->tm_min, tm_now->tm_sec) ;
  • tm结构在c/c++中处理日期和时间相关的操作时,显得尤为重要,tm结构以c结构的形式保存日期和时间,大多数与事件相关的函数都使用了tm结构,下面的实例使用了tm结构和各种与日期和时间相关的函数 #include #...
  • 大家都是着急下班的 程序员,何必写一大堆理论来装逼浪费时间呢? 早点复制 过去 早点下班不香嘛? 使用方法如下: char cNow[32] = { 0 };... time_t now = time(NULL);...tm_year + 1900, pNow->tm_mon + 1, pNo
  • Python基础之时间模块

    千次阅读 2018-08-08 18:38:05
    time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=10, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0) 结构化时间-->时间戳 1500000000.0 结构化时间-->字符串时间 2018-08-08 18:12:...
  • printf("%d-%d-%d %d:%d:%d\n",time->tm_year+1900,time->tm_mon+1,time->tm_mday,time->tm_hour,time->tm_min,time->tm_sec); } struct tm str2time(char * str){ struct tm *tmp_time = (struct tm *)malloc...
  • python3 时间日期处理函数

    千次阅读 2018-04-17 11:10:32
    # time.struct_time(tm_year=2018, tm_mon=1, tm_mday=25, tm_hour=0, tm_min=42, tm_sec=40, tm_wday=3, tm_yday=25, tm_isdst=0) # cur year: 2018 # cur month: 1 # cur date: 25 # cur hour: 0 # cur min: 42 # ...
  • 在linux下,若想使用 struct tm 从一个字符串中获取时刻秒数,则必须初始化。 下面的示例代码,在服务器中运行时,tmTime 的值会出现不为1595410483 的情况,导致程序处理出错。 struct tm when;...when.tm_year,
  • 对python中time模块中的方法和涉及到的三个...time.struct_time(tm_year=2020, tm_mon=5, tm_mday=26, tm_hour=16, tm_min=18, tm_sec=44, tm_wday=1, tm_yday=147, tm_isdst=0) 属性 含义 tm_year 年份 t
  • 【坑爹】mktime中的 tm_isdst解决办法

    千次阅读 2015-10-07 17:35:37
    不对 tm 结构体中的 tm_isdst 赋值,在不同机器上会出现 tm_isdst 默认值不同  也就是说最终,mktime 算出来的时候会有一个小时的差别。 #include #include int main(void) { tm maskTimetm; m
  • info.tm_year = year-1900; info.tm_mon = mon; info.tm_mday = day; info.tm_hour = hour; info.tm_min = min; info.tm_sec = sec; info.tm_wday = week; return mktime(&info); // mktime()函数可以将tm...
  • C++时间函数用法总结(部分)

    千次阅读 2016-11-02 21:48:27
    &st.tm_mday, mon, &st.tm_year, &st.tm_hour, &st.tm_min, &st.tm_sec); for (int i=0;i;i++) if (0==stricmp(mn[i],mon)) {st.tm_mon=i; break;} st.tm_year-=1900; tt=mktime(&st);//获取时间戳 if (-1!=tt...
  • ASN1_TIME 和 TIME_T转换

    千次阅读 2018-12-27 17:34:45
    Openssl   ... &tm.tm_year, &tm.tm_mon, &tm.tm_mday, &tm.tm_hour, &tm.tm_min, &tm.tm_sec); tm.tm_year -= 1900; tm.tm_mon--; return mktime(&tm); } 参考链接:     ...
  • Python之日期与时间处理模块(date和datetime)

    万次阅读 多人点赞 2017-02-09 12:19:43
    time.struct_time(tm_year=2017, tm_mon=2, tm_mday=4, tm_hour=14, tm_min=12, tm_sec=0, tm_wday=5, tm_yday=35, tm_isdst=-1) >>> time.strptime('2017/02/04 14:12', '%Y/%m/%d %H:%M') time.struct_time(tm_...
  • 【分解的时间 struct tm】 struct tm 是linux中用来保存分解时间的数据结构。其定义在time.h中,可通过下面命令找到 $whereis time.h 其结构定义如下,基本都是整型的。有几点需要注意的 1、tm_sec 表示秒,...
  • time time_t tm用法

    千次阅读 2019-04-19 10:22:00
    最近搞视频检索,涉及到很多时间的计算。顺便记录下一些基本用法。 一、gmtime用法 #include <stdio.h> #include <stdlib.h> #include <time.h>... struct tm *timenow; if (t == ...
  • 我的mysql安装后,保存删除表数据总是出现#1929 Incorrect datetime value: '' for column 'createtime' 的报错提醒,导致不能删除表里数据; 原因: 5以上的版本如果时期时间是空值应该要写NULL;...
  • Python NTP时间同步

    千次阅读 2018-06-30 16:06:04
    tm_year, tm_mon, tm_mday, tm_hour, tm_min, tm_sec, tm_wday, tm_yday, tm_isdst = time.gmtime(time_t) win32api.SetSystemTime(tm_year, tm_mon, tm_wday, tm_mday, tm_hour, tm_min, tm_sec, 0) def ...
  • printf ( “%d/%d/%d %d:%d:%d\n”,lt->tm_year+1900, lt->tm_mon, lt->tm_mday, lt->tm_hour, lt->tm_min, lt->tm_sec);//输出结果 return 0; } 注意事项: struct tm中的tm_year 值为实际年减去1900, ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 27,406
精华内容 10,962
关键字:

tm_year