精华内容
下载资源
问答
  • C++时间日期的使用

    千次阅读 2017-10-26 23:19:48
    C++时间日期的使用 一、获取现在的时间 代码: #include #include int main () { time_t curtime; time(&curtime); printf("当前时间 = %s", ctime(&curtime)); return(0); }输出: 当前时间 = Thu Oct 26...

    C++时间日期的使用

    一、获取现在的时间
    代码:
    #include <stdio.h>
    #include <time.h>
    int main ()
    {
       time_t curtime;
       time(&curtime);
       printf("当前时间 = %s", ctime(&curtime));
       return(0);
    }
    输出:
    当前时间 = Thu Oct 26 23:20:11 2017
    请按任意键继续. . .
    二、获得时间差

    C 库函数 - difftime()

    描述

    C 库函数 double difftime(time_t time1, time_t time2) 返回 time1 和 time2 之间相差的秒数 (time1 - time2)。这两个时间是在日历时间中指定的,表示了自纪元 Epoch(协调世界时 UTC:1970-01-01 00:00:00)起经过的时间。

    声明

    下面是 difftime() 函数的声明。

    double difftime(time_t time1, time_t time2)

    参数

    • time1 -- 这是表示结束时间的 time_t 对象。
    • time2 -- 这是表示开始时间的 time_t 对象。

    返回值

    该函数返回以双精度浮点型 double 值表示的两个时间之间相差的秒数 (time2 - time1)。

    实例

    下面的实例演示了 difftime() 函数的用法。

    #include <iostream>
    #include <ctime>
    #include <Windows.h>
    using namespace std;
    int main()
    {
      time_t start_t, end_t;
      time(&start_t);
      Sleep(5000);
      time(&end_t);
      cout << start_t << endl;
      cout << end_t << endl;
      cout << difftime(end_t, start_t) << endl;
      system("pause");
      return 0;
    }
    输出结果:
    1509031681
    1509031686
    5
    请按任意键继续. . .
    三、使用示例

    当前日期和时间

    下面的实例获取当前系统的日期和时间,包括本地时间和协调世界时(UTC)。

     
    #include <iostream>
    #include <ctime>
    using namespace std;
    int main( )
    {
       // 基于当前系统的当前日期/时间
       time_t now = time(0); 
       // 把 now 转换为字符串形式
       char* dt = ctime(&now);
       cout << "本地日期和时间:" << dt << endl;
       // 把 now 转换为 tm 结构
       tm *gmtm = gmtime(&now);
       dt = asctime(gmtm);
       cout << "UTC 日期和时间:"<< dt << endl;
    }
    输出:
    本地日期和时间:Thu Oct 26 23:34:27 2017
    
    UTC 日期和时间:Thu Oct 26 15:34:27 2017
    
    请按任意键继续. . .
    

    使用结构 tm 格式化时间

    tm 结构在 C/C++ 中处理日期和时间相关的操作时,显得尤为重要。tm 结构以 C 结构的形式保存日期和时间。大多数与时间相关的函数都使用了 tm 结构。下面的实例使用了 tm 结构和各种与日期和时间相关的函数。

    在练习使用结构之前,需要对 C 结构有基本的了解,并懂得如何使用箭头 -> 运算符来访问结构成员。

    #include <iostream>
    #include <ctime>
    using namespace std;
    int main( )
    {
       // 基于当前系统的当前日期/时间
       time_t now = time(0);
       cout << "1970 到目前经过秒数:" << now << endl;
       tm *ltm = localtime(&now);
       // 输出 tm 结构的各个组成部分
       cout << "年: "<< 1900 + ltm->tm_year << endl;
       cout << "月: "<< 1 + ltm->tm_mon<< endl;
       cout << "日: "<<  ltm->tm_mday << endl;
       cout << "时间: "<< ltm->tm_hour << ":";
       cout << ltm->tm_min << ":";
       cout << ltm->tm_sec << endl;
    }
    输出:

    1970 到目前经过秒数:1509032182
    年: 2017
    月: 10
    日: 26
    时间: 23:36:22
    请按任意键继续. . .
    








    展开全文
  • C/C++时间函数的使用

    万次阅读 2010-03-14 22:04:00
    一、获取日历时间time_t是定义在time.h中的一个类型,表示一个日历时间,也就是从1970年1月1日0时0分0秒到此时的秒数,原型是:typedef long time_t; /* time value */可以看出time_t其实是一个长整型,由于长整型能...

    一、获取日历时间
    time_t是定义在time.h中的一个类型,表示一个日历时间,也就是从1970年1月1日0时0分0秒到此时的秒数,原型是:

     typedef long time_t;        /* time value */


    可以看出time_t其实是一个长整型,由于长整型能表示的数值有限,因此它能表示的最迟时间是2038年1月18日19时14分07秒。

    函数time可以获取当前日历时间时间,time的定义: 

    time_t time(time_t *)

    #include <iostream> 
    #include <time.h> 
    using namespace std; 
    int main(void) 
    { 
        time_t nowtime; 
        nowtime = time(NULL); //获取当前时间 
        cout << nowtime << endl; 
        return 0; 
    } 

    输出结果:1268575163

     

    二、获取本地时间
    time_t只是一个长整型,不符合我们的使用习惯,需要转换成本地时间,就要用到tm结构,time.h中结构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 */
    };


    可以看出,这个机构定义了年、月、日、时、分、秒、星期、当年中的某一天、夏令时。可以用这个结构很方便的显示时间。

    用localtime获取当前系统时间,该函数将一个time_t时间转换成tm结构表示的时间,函数原型:

     struct tm * localtime(const time_t *)

    使用gmtime函数获取格林尼治时间,函数原型:

     struct tm * gmtime(const time_t *)

    为了方便显示时间,定义了一个函数void dsptime(const struct tm *);

    #include <iostream>
    #include <time.h>
    using namespace std;
    void dsptime(const struct tm *); //输出时间。
    
    int main(void)
    {
    	time_t nowtime;
    	nowtime = time(NULL); //获取日历时间
    	cout << nowtime << endl; //输出nowtime
    	struct tm *local, *gm;
    	local = localtime(&nowtime); //获取当前系统时间
    	dsptime(local);
    	gm = gmtime(&nowtime); //获取格林尼治时间
    	dsptime(gm);
    	return 0;
    }
    void dsptime(const struct tm *ptm)
    {
    	char *pxq[] = {"日", "一", "二", "三", "四", "五", "六"};
    	cout << ptm->tm_year + 1900 << "年" << ptm->tm_mon + 1 << "月" << ptm->tm_mday << "日 " ;
    	cout << ptm->tm_hour << ":" << ptm->tm_min << ":" << ptm->tm_sec << " " ;
    	cout << " 星期" << pxq[ptm->tm_wday] << " 当年的第" << ptm->tm_yday << "天 " << endl;
    }

    输出结果:
    1268575163
    2010年3月14日 21:59:23  星期日 当年的第72天
    2010年3月14日 13:59:23  星期日 当年的第72天

     

    三、输出时间
    C/C++语言提供了用字符串格式表示时间的函数。

    char * asctime(const struct tm *)
    char * ctime(const time_t *)

    这两个函数返回值都是一个表示时间的字符串,区别在于传入的参数不同。

    #include <iostream>
    #include <time.h>
    using namespace std;
    int main(void)
    {
    	time_t nowtime;
    	nowtime = time(NULL); //获取日历时间
    	cout << nowtime << endl; //输出nowtime
    	struct tm *local;
    	local = localtime(&nowtime); //获取当前系统时间
    	cout << asctime(local) ;
    	cout << ctime(&nowtime) ;
    	return 0;
    }

    输出结果:
    1268575163
    Sun Mar 14 13:59:23 2010
    Sun Mar 14 21:59:23 2010

     

    四、计算时间间隔
    可以通过difftime来计算两个时间的间隔,可以精确到秒,函数原型:

     double difftime(time_t, time_t)

    要想精确到毫秒,就要使用clock函数了,函数原型:

     clock_t clock(void)

    从定义可以看出clock返回一个clock_t类型,这个类型也定义在time.h中,原型是: 

     typedef long clock_t

    clock_t也是一个长整型,表示的是从程序开始运行到执行clock函数时所经过的cpu时钟计时单元数。

    #include <iostream> #include <time.h>
    using namespace std;
    int main(void)
    {
    	time_t start, ends;
    	clock_t cstart, cends;
    	start = time(NULL);
    	cstart = clock();
    	system("pause");
    	ends = time(NULL);
    	cends = clock();
    	cout << "时间差:" << difftime(ends, start) << endl;
    	cout << "Clock时间差:" << cends - cstart << endl;
    	return 0;
    }

    输出结果:
    请按任意键继续. . .
    时间差:3
    Clock时间差:3094

     

    在time.h中定义了一个CLOCKS_PER_SEC

     /* Clock ticks macro - ANSI version */
     #define CLOCKS_PER_SEC  1000

    表示1秒钟内有多少个时钟计时单元,在标准C/C++中,最小的计时单位是1毫秒。


    五、自定义时间格式
    C/C++在time.h中提供了一个自定义时间格式的函数strftime,函数原型:

     size_t strftime(char *strDest, size_t maxsize, const char *format, const struct tm *timeptr);

    参数说明:
     char *strDest:用来存放格式化后的字符串缓存,
     size_t maxsize:指定最多可以输出的字符数,
     const char *format:格式化字符串,
     const struct tm *timeptr:要转换的时间。

    可使用的格式化字符串:
    %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 <iostream> 
    #include <time.h> 
    using namespace std;
    
    int main(void)
    {
    	time_t nowtime;
    	nowtime = time(NULL); //获取日历时间
    	cout << nowtime << endl; //输出nowtime
    	struct tm *local;
    	local = localtime(&nowtime); //获取当前系统时间
    	char buf[80];
    	strftime(buf, 80, "格式化输出:%Y-%m-%d %H:%M:%S", local);
    	cout << buf << endl;
    	return 0;
    }

    输出结果:
    1268575163
    格式化输出:2010-03-14 21:59:23

     

     

     

     

     

     

    展开全文
  • c++ 时间类型详解(time_t和tm)

    万次阅读 多人点赞 2014-03-02 15:29:57
    Unix时间戳(Unix timestamp),或称Unix时间(Unix time)、POSIX时间(POSIX time),是一种时间表示方式,定义为从格林威治时间1970年01月01日00时00分00秒起至现在的总秒数。Unix时间戳不仅被使用在Unix 系统、类Unix...

    原文: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
    /*gettime1.c*/
    #include <time.h>
    
    int main()
    {
        time_t timep;
       
        time(&timep); /*获取time_t类型的当前时间*/
        /*用gmtime将time_t类型的时间转换为struct tm类型的时间,按没有经过时区转换的UTC时间
          然后再用asctime转换为我们常见的格式 Fri Jan 11 17:25:24 2008
        */
        printf("%s", asctime(gmtime(&timep)));
        return 0;
    }
    编译并运行:
    $gcc -o gettime1 gettime1.c
    $./gettime1

    Fri Jan 11 17:04:08 2008


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

    下载: gettime2.c
    /* gettime2.c*/
    #include <time.h>
    
    int main()
    {
        time_t timep;
       
        time(&timep); /*获取time_t类型当前时间*/   
        /*转换为常见的字符串:Fri Jan 11 17:04:08 2008*/
        printf("%s", ctime(&timep));
        return 0;
    }
    编译并运行:
    $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

    /*gettime3.c */
    #include <time.h>
    
    int main()
    {
        char *wday[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
        time_t timep;
        struct tm *p;
       
        time(&timep); /*获得time_t结构的时间,UTC时间*/
        p = gmtime(&timep); /*转换为struct tm结构的UTC时间*/
        printf("%d/%d/%d ", 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;
    }
    编译并运行:
    $gcc -o gettime3 gettime3.c
    $./gettime3
    2008/1/11 Fri 17:42:54
    从这个时间结果上来看,它和gettime1保持一致。


    下载: gettime4.c

    /*gettime4.c*/
    #include <time.h>
    
    int main()
    {
        char *wday[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
        time_t timep;
        struct tm *p;
       
        time(&timep); /*获得time_t结构的时间,UTC时间*/
        p = localtime(&timep); /*转换为struct tm结构的当地时间*/
        printf("%d/%d/%d ", 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;
    }
    编译并运行:
    $gcc -o gettime4 gettime4.c
    $./gettime4
    2008/1/12 Sat 1:49:29
    从上面的结果我们可以这样说:

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

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


    下载: gettime5.c

    /*gettime5.c*/
    #include <time.h>
    
    int main()
    {
        time_t timep;
        struct tm *p;
    
        time(&timep); /*当前time_t类型UTC时间*/
        printf("time():%d\n",timep);
        p = localtime(&timep); /*转换为本地的tm结构的时间按*/
        timep = mktime(p); /*重新转换为time_t类型的UTC时间,这里有一个时区的转换*/ 
        //by lizp 错误,没有时区转换, 将struct tm 结构的时间转换为从1970年至p的秒数
        printf("time()->localtime()->mktime(): %d\n", timep);
        return 0;
    }
    编译并运行:
    $gcc -o gettime5 gettime5.c
    $./gettime5
    time():1200074913
    time()->localtime()->mktime(): 1200074913

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


    下载: gettime6.c

    /*gettime6.c */
    #include <time.h>
    
    int main()
    {
        time_t timep;
        struct tm *p;
    
        time(&timep);  /*得到time_t类型的UTC时间*/
        printf("time():%d\n",timep);
        p = gmtime(&timep); /*得到tm结构的UTC时间*/
        timep = mktime(p); /*转换,这里会有时区的转换*/ //by lizp 错误,没有时区转换, 将struct tm 结构的时间转换为从1970年至p的秒数
        printf("time()->gmtime()->mktime(): %d\n", timep);
        return 0;
    }
    编译并运行:
    $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小时制显示,就象下面这段程序:
    #include "time.h"
    #include "stdio.h"
    int main(void)
    {
        struct tm *ptr;
        time_t lt;
        char str[80];
        lt=time(NULL);
        ptr=localtime(&lt);
        strftime(str,100,"It is now %I %p",ptr);
        printf(str);
        return 0;
    }
    其运行结果为:

    It is now 4PM


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

    #include<stdio.h>
    #include<string.h>
    #include<time.h>
    int main( void )
    {
        struct tm *newtime;
        char tmpbuf[128];
        time_t lt1;
       
    time( &lt1 );
        newtime=localtime(&lt1);
       
    strftime( tmpbuf, 128, "Today is %A, the %d day of %B in the year %Y.\n", newtime);
        printf(tmpbuf);
    
    return 0;
    }

    其运行结果为:

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




    欢迎加入"C/C++梦之队" 学习群:226157456




    关注【SunLogging】 
    这里写图片描述 
    长按或扫码二维码,在手机端阅读更多内容

    展开全文
  • C++时间类的运算符重载

    千次阅读 2014-08-05 14:27:09
    C++时间类的运算符重载 定义一个时间类Time,其数据成员为表示时间的小时(hour)、分(minute),秒(second)。 重载运算符“+”,使之能用于时间对象的加法运算;重载运算符“ (1)参加运算的两个操作数可以...
    

    Description

    C++时间类的运算符重载
    定义一个时间类Time,其数据成员为表示时间的小时(hour)、分(minute),秒(second)。
    重载运算符“+”,使之能用于时间对象的加法运算;重载运算符“<<”,使之能用于时间对象的输出操作。
    (1)参加运算的两个操作数可以都是时间类对象,也可以其中有一个是整数(表示秒),顺序任意。
    例如,t1+t2,i+t1,t1+i均合法(设i为整数表示秒数, t1,t2为时间类Time对象)。
    (2)输出时间对象的方式为 小时:分:秒,例如 14:23:55、00:00:00、23:59:59等。

    编写程序,分别求两个时间对象之和、整数和时间对象之和,时间对象和整数之和,并且输出。

    请在下面的程序段基础上完成设计:
    #include <iostream>
    using namespace std;

    class Time
    {
    public:
    Time():hour(0),minute(0),second(0) {}
    Time(int h,int m,int s) {
    hour=(h>=24||h<0)?0:h;
    minute=(m>=60||m<0)?0:m;
    second=(s>=60||s<0)?0:s;
    }
    Time operator+(Time &);
    Time operator+(int &);
    friend Time operator+(int,Time &);
    friend ostream& operator << (ostream& output, Time & c);
    private:
    int hour;
    int minute;
    int second;
    };

    //将程序需要的其他成份写在下面,只提交begin到end部分的代码
    //******************** begin ********************


    //********************* end ********************

    int main()
    {
    //测试Time类对象加Time类对象
    int hour,minute,second;
    cin>>hour>>minute>>second;
    Time t1(hour,minute,second);
    cin>>hour>>minute>>second;
    Time t2(hour,minute,second);
    Time t3=t1+t2;
    cout<<"t1+t2=";
    cout<<t3;

    //测试时间对象加整数
    int i;
    cin>>hour>>minute>>second;
    cin>>i;
    t3=Time(hour,minute,second)+i;
    cout<<"t1+i=";
    cout<<t3;

    //测试整数加时间对象
    cin>>i;
    cin>>hour>>minute>>second;
    t1=Time(hour,minute,second);
    t3=i+t1;
    cout<<"i+t1=";
    cout<<t3;

    return 0;

    Input

    一个时间类的小时 分 秒,另一个时间类的小时 分 秒(注意要符合实际)
    一个时间类的小时 分 秒,一个整数(表示秒数)
    一个整数(表示秒数),一个时间类的小时 分 秒

    Output

    两个时间之和、时间和整数之和,整数和时间之和。

    Sample Input

    1 2 3 4 5 60 0 0 20059 14 59 1

    Sample Output

    t1+t2=5:7:9t1+i=0:3:20i+t1=15:0:0
    C++代码:
    #include <iostream>
     using namespace std;
    class Time
     {
     public:
     Time():hour(0),minute(0),second(0) {}
     Time(int h,int m,int s) {
     hour=(h>=24||h<0)?0:h;
     minute=(m>=60||m<0)?0:m;
     second=(s>=60||s<0)?0:s;
     }
     Time operator+(Time &);
     Time operator+(int &);
     friend Time operator+(int,Time &);
     friend ostream& operator << (ostream& output, Time & c);
     private:
     int hour;
     int minute;
     int second;
     };
    //将程序需要的其他成份写在下面,只提交begin到end部分的代码
    //******************** begin ********************
    Time Time::operator+(Time &t)
    {
        int h,m,s;
        s=second+t.second;
        m=minute+t.minute;
        h=hour+t.hour;
        if (s>59)
        {
            s-=60;
            m++;
        }
        if (m>59)
        {
            m-=60;
            h++;
        }
        while (h>23) h-=24;
        Time t0(h,m,s);
        return t0;
    }
    Time Time::operator+(int &i)
    {
        int ss=i%60;
        int mm=(i/60)%60;
        int hh=i/3600;
        Time t0(hh,mm,ss);
        return *this+t0;
    }
    Time operator+(int i,Time &c1)
    {
        int ss=i%60;
        int mm=(i/60)%60;
        int hh=i/3600;
        Time t0(hh,mm,ss);
        return t0+c1;
    }
    ostream& operator << (ostream& output, Time & c)
    {
        output<<c.hour<<":"<<c.minute<<":"<<c.second<<endl;
        return output;
    }
     //********************* end ********************
     int main()
     {
     //测试Time类对象加Time类对象
    int hour,minute,second;
     cin>>hour>>minute>>second;
     Time t1(hour,minute,second);
     cin>>hour>>minute>>second;
     Time t2(hour,minute,second);
     Time t3=t1+t2;
     cout<<"t1+t2=";
     cout<<t3;
    //测试时间对象加整数
    int i;
     cin>>hour>>minute>>second;
     cin>>i;
     t3=Time(hour,minute,second)+i;
     cout<<"t1+i=";
     cout<<t3;
    //测试整数加时间对象
    cin>>i;
     cin>>hour>>minute>>second;
     t1=Time(hour,minute,second);
     t3=i+t1;
     cout<<"i+t1=";
     cout<<t3;
    return 0;
     }
    展开全文
  • 转载:... 1. C++标准库中的时间需要引用time.h,可以取的本地时间或者格林威治时间,只能精确到秒 #include   /*包含time头文件*/ #include
  • C++ 时间复杂度详解

    千次阅读 2017-05-09 09:59:40
    注意定义的方式与细节!!! 定义: ...算法中基本运算(就是指最深层的循环内的语句)与T(n) 同数量级,所以通常采用算法中基本运算的频度 f(n) 来分析算法的时间复杂度。我们将 f(n) 中随 n 增
  • 关于struct tm的介绍可看 【C/C++时间系列】struct tm 通过strftime转换成字符串 。 【strptime】 strptime主要用于把字符串转换成分解时间,与strftime的作用相反。都位于time.h中,其原始模型如下 /* Parse S...
  • C++时间延时控制

    千次阅读 2017-04-05 16:35:40
    普通计数的方式进行延时,采用的是系统时间,并不一定是以秒为单位,eg: long wait = 0; while(wait  wait++; 并不能确定具体延时多久。 //------------------------------------------------------
  • c++时间间隔运算

    千次阅读 2016-03-01 01:19:07
    #include #include #include #include "time.h" #include using namespace std; //strTime格式为 20160212,size表示需减去的天数 20160212-1=20160211 string reduceTime(const std::string& strTime, int ...
  • C++ 时间标记类

    千次阅读 2014-02-28 15:26:13
    时间标记记录某一个瞬间时间 创建时间标记类:  ——在事件发生时记录一个瞬间时间  ——将时间标记作为整数打印  ——将时间标记作为字符串打印  ——将时间标记分解为年月日时分秒打印 TimeStamp.h #...
  • 【时间戳】Unix时间戳(Unix timestamp),或称Unix时间(Unix time)、POSIX时间(POSIX time),是一种时间表示方式,定义为从格林威治时间1970年01月01日00时00分00秒起至现在的总秒数 ############## 【time()】获取...
  • C++时间日期的处理ctime

    千次阅读 2019-04-10 10:58:33
    //注意这里的时间是现在时间减去1900年1月1日0时0分0秒的时间 time_t timer; time(&timer); timer = time(NULL);  2)  ctime  char* ctime (const time_t * timer); //将time_t转换成字符串 cout (&...
  • C/C++ 时间

    万次阅读 2013-04-09 09:58:39
    表示时间方法是时间的基点timepoint+duaration的形式; 而变表示时间的类型有C tm结构体 struct tm { int tm_sec; /*秒,正常范围0-59, 但允许至61*/ int tm_min; /*分钟,0-59*/ int tm_hour; /*小时, 0-...
  • Linux C++ 时间与日期

    千次阅读 2016-07-04 17:03:44
    linux下存储时间常见的有两种存储方式,一个是从1970年到现在经过了多少秒,一个是用一个结构来分别存储年月日时分秒的。 time_t 这种类型就是用来存储从1970年到现在经过了多少秒,要想更精确一点,可以用结构...
  • Linux C++ 时间格式化

    千次阅读 2016-10-17 15:47:16
    /*************************************************************************  > File Name: time.cpp  > Author: chenhui  > Mail: *********  > Created Time: 2016年03月10日 11:20:58 ...
  • linux中c++时间时区简介

    千次阅读 2013-09-03 17:48:01
    c++时间主要分为GMT时间和本地时间。GMT时间叫做格林威治时间,也就是UTC时间,这个时间有点特殊,它所在时区为0,在这个时区内,本地时间和GMT时间完全一致,地球上其他地方的时间都得在这个时间基础上加一个时区...
  • C++时间与字符串转换

    千次阅读 2017-01-17 14:12:16
    1)time_t类型,这本质上是一个长整数,表示从1970-01-01 00:00:00到目前计时时间的秒数,如果需要更精确一点的,可以使用timeval精确到毫秒。    2)tm结构,这本质上是一个结构体,里面包含了各时间字段  ...
  • c/c++ 时间函数总结 linux

    万次阅读 2013-10-06 13:55:11
    Linux c/c++关于时间函数的总结     很想花点时间整理下Linux c/c++关于时间函数,今天…   关于时间的存储 linux下存储时间常见的有两种存储方式,一个是从1970年到现在经过了多少秒,一个是用一个结构来分别...
  • C/C++ 时间转换与表示

    千次阅读 2019-07-01 16:38:43
    https://www.cnblogs.com/winkyao/archive/2012/03/17/2403962.html
  • c/c++ 时间函数 localtime 坑

    千次阅读 2017-10-30 14:42:11
    localtime() 函数返回的数据 struct tm* 内存空间由其自己管理。  ​且连续调用时,第二次的调用会修改第一次的数据。  返回的时间为本地时区时间
  • 在做C++的项目过程中,原来对于时间的处理部分直接调用了Boost库中提供的gregorian和posix_time命名空间中的方法。现在由于某些方面的原因,需要解除对boost库的依赖。请问除了调用c++基本库中的方法有什么其他的...
  • Linux下C/C++时间函数详解

    千次阅读 2018-01-08 16:35:01
    linux几种时间函数总结 ... 最近的工作中用到的时间函数比较频繁,今天抽时间总结一下,在linux下,常用的获取时间的函数有如下几个:  asctime, ctime, gmtime, localtime, gettimeo
  • 程序到目前为止所使用的时间(用户时间+系统时间)。 结果/时钟_秒是程序时间(以秒为单位) /* Time used by the program so far (user time + system time). The result / CLOCKS_PER_SECOND is program time in ...
  • UE4 C++ 时间线(TimeLine)

    千次阅读 2017-08-18 13:22:14
    使用时间线让物体缓慢移动 在头文件中声明移动的初始位置和目标位置UPROPERTY(EditAnyWhere, Category = "PlatformControls") FVector EndLocation; UPROPERTY(EditAnyWhere, Category = "PlatformControls") ...
  • Unix时间戳(Unix timestamp),或称Unix时间(Unix time)、POSIX时间(POSIX time),是一种时间表示方式,定义为从格林威治时间1970年01月01日00时00分00秒起至现在的总秒数。Unix时间戳不仅被使用在Unix 系统、类...
  • 在C/C++中,对字符串的操作有很多值得注意的问题,同样,C/C++时间的操作也有许多值得大家注意的地方。下面主要介绍在C/C++时间和日期的使用方法. 通过学习许多C/C++库,你可以有很多操作、使用时间的方法。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 64,368
精华内容 25,747
关键字:

c++时间

c++ 订阅