精华内容
下载资源
问答
  • C++时间函数

    2019-08-03 16:34:15
  • c++时间函数

    2014-05-04 18:18:17
    关于C/C++时间函数的一些性质和基本用法
  • c++时间函数资料c++时间函数资料c++时间函数资料
  • c/c++时间函数

    2016-06-28 10:59:40
    c/c++时间函数 UNIX及Linux的时间系统是由「新纪元时间」Epoch开始计算起,单位为秒。 Epoch是指定为1970年1月1日凌晨零点零分零秒,格林威治时间。 目前大部份的UNIX系统都是用32位来记录时间,正值表示为...

    c/c++时间函数


    UNIX及Linux的时间系统是由「新纪元时间」Epoch开始计算起,单位为秒。
    Epoch是指定为1970年1月1日凌晨零点零分零秒,格林威治时间。
    目前大部份的UNIX系统都是用32位来记录时间,正值表示为1970以后,负值则表示1970年以前。


    下面看下time.h中的time函数,sys/time.h中的gettimeofday函数


    #include<time.h>
    #include<sys/time.h>
    #include<stdio.h>
    int main()
    {
    time_t tt;
    struct timeval tv;     
    tt=time(NULL);
    gettimeofday(&tv,NULL);
    printf("time_t sec is %d\n", tt);
    printf("gettimeofday tv_sec is %d, usec is %d \n", tv.tv_sec, tv.tv_usec); 
    }


    PS: time 与 gettimeofday 两个函数得到的都是从Epoch开始到当前的秒数(tt=tv.tv_sec),
    而后者还能得到更精细的微秒级结果,即tv_sec*(10^6) + tv_usec为从Epoch开始到当前的微秒数。
    ================================================================================================
    time_t t1 = time(NULL);
    time_t=int64=Unix纪元1970年1月1日0点到现在的秒数
    time.h


    struct tm* t2 = localtime(&t1);
    秒数转为本地时间年月日格式


    struct tm* t3 = gmtime(&t1);
    秒数转为格林威治时间


    int gettimeofday(struct timeval *, struct timezone *);
    sys/time.h
    精确到微妙
    struct timeval
    {
    long tv_sec; // seconds
    long tv_usec;    // microSeconds
    };

    展开全文
  • 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...函数time可以获取当前日历时间时间

    一、获取日历时间
    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++时间函数资料

    2013-09-05 20:47:44
    主要是 c++中关于时间函数的介绍 用法等
  • C/C++时间函数使用方法 C/C++对时间的操作也有许多值得大家注意的地方。最近,在技术群中有很多网友也多次问到过C++语言中对时间的操作、获取和显示等等的问题。下面,在这篇文章中,笔者将主要介绍在C/C++中时间和...
  • vc/c++时间函数

    千次阅读 2008-06-06 15:53:00
    vc/c++时间函数 一、MFC类MFC提供了两个日期和时间类CTime和CTimeSpan,分别代表相对时间和绝对时间。CTime是基于格林威治平均时间(GMT)的,本地的时间由环境变量TZ决定。CTimeSpan代表了时间间隔。CTime类由下列...

    vc/c++时间函数

     

    一、MFC类

    MFC提供了两个日期和时间类CTime和CTimeSpan,分别代表相对时间和绝对时间。CTime是基于格林威治平均时间(GMT)的,本地的时间由环境变量TZ决定。CTimeSpan代表了时间间隔。

    CTime类由下列成员函数

    CTime()

    创建一个CTime对象。

    GetCurrentTime()

    由当前时间创建一个CTime对象。

    GetTime()

    由CTime对象返回一个time_t变量。

    GetYear()

    获取CTime对象代表的年。

    GetMonth()

    获取CTime对象代表的月。

    GetDay() 获取CTime对象代表的日期。

    GetHour() 获取CTime对象代表的小时。

    GetMinute()获取CTime对象代表的分。

    GetSecond() 获取CTime对象代表的秒。

    GetDayOfWeek() 获取CTime对象代表的周日,1代表周日,2代表周-等等。

    Format() 将字符串转换成一个基于本地时区的格式字符串。

    FormatGmt() 将字符串转换成一个基于UTC(世界时)的格式字符串。

    operator = 赋予新的时间

    operator + 增加CTime和CTimeSpan对象。

    operator – 减小CTime和CTimeSpan对象。

    operator += CTime对象加一个CTimeSpan对象。

    operator -= CTime对象减一个CTimeSpan对象。

    operator == 比较两个绝对时间是否相等。

    operator != 比较两个绝对时间是否不相等。

    operator < 比较两个绝对时间,是否前一个大于后一个。

    operator > 比较两个绝对时间,是否前一个小于后一个。

    operator >= 比较两个绝对时间,是否前一个大于等于后一个。

    operator <= 比较两个绝对时间,是否前一个小于等于后一个
     
    二、总结
     
    首先看几个函数的原型的声明(在time.h中):

          clock_t clock( void )      clock_t是用来保存时间的数据类型,是long型

          double difftime(time_t time1, time_t time0);   取时间间隔的函数

          time_t time(time_t * timer);   日历时间函数

          char * asctime(const struct tm * timeptr);   将tm 类的时间结构转化为 固定时间格式

          char * ctime(const time_t *timer); 将日历时间转化为 固定时间格式

          time_t mktime(struct tm * timeptr);   以年、月、日、时、分、秒等分量保存的时间结构

          struct tm * gmtime(const time_t *timer);   将日历时间转化为格林尼治时间
                                            
          struct tm * localtime(const time_t * timer); 将日历时间转化为当地时间

          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代表一月) - 取值区间为[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()为负。*/}


       1.获取间隔时间
             1.   clock_t start, finish;
                 long     i = 10000000;
                 double   duration;
                 start = clock();
                 while( i-- ) ;
                 finish = clock();
                 duration = (double)(finish - start) / CLOCKS_PER_SEC;
                 cout<<duration;
                 输出的是: i从10000000减到零用的时间,精确到毫秒
              2.
                 double pause1;
                 time_t start,end;
                 start = time(NULL);
                 system("pause");
                 end = time(NULL);
                 pause1 =difftime(end,start);
                 cout<<pause1;
                 输出的是: 你停顿(pause)的时间,精确到秒
      
       2.获得日历时间
                 time_t lt;
                 lt =time(NULL);//(还不清楚带参的和不带参的区别)
                 cout<<lt;
                 输出的是: 从1970年1月1日0时0分0秒到此时的秒数
      
      
       3.获得日期和时间

             1. 将日历时间转化为本地时间(格林尼治时间)
               struct tm *local
               time_t t;
               t=time(NULL);
               local=localtime(&t);
               //local=gmtime(&t);
               cout<<local->tm_hour;
             2. 以固定的时间格式获得日期和时间:看清这两个函数的参和返回值的类型
                                           char * asctime(const struct tm * timeptr);
                                           char * ctime(const time_t *timer);

                   1.将日历时间直接转换为 固定的时间格式的日期和时间

                       char * jieguo;
                       time_t lt;
                       lt =time(NULL);
                       jieguo =ctime(&lt);
                       cout<< jieguo;

                   2.将日历时间经过localtime()和gmtime()转换后在转换为固定的时间格式的日期和时间
                       struct tm *local;
                       char * jieguo;
                       time_t t;
                       t =time(NULL);
                       local=localtime(&t);
                       //local=gmtime(&t);
                       jieguo=asctime(local);
                       cout<< jieguo;

    4.分解时间转化为日历时间

    这里说的分解时间就是以年、月、日、时、分、秒等分量保存的时间结构,在C/C++中是tm结构。我们可

    以使用mktime()函数将用tm结构表示的时间转化为日历时间。其函数原型如下:

    time_t mktime(struct tm * timeptr);

    其返回值就是转化后的日历时间。这样我们就可以先制定一个分解时间,然后对这个时间进行操作了,

    下面的例子可以计算出1997年7月1日是星期几:

    #include "time.h"
    #include "stdio.h"
    #include "stdlib.h"
    int main(void)
    {
    struct tm t;
    time_t t_of_day;
    t.tm_year=1997-1900;
    t.tm_mon=6;
    t.tm_mday=1;
    t.tm_hour=0;
    t.tm_min=0;
    t.tm_sec=1;
    t.tm_isdst=0;
    t_of_day=mktime(&t);
    printf(ctime(&t_of_day));
    return 0;
    }

    运行结果:

    Tue Jul 01 00:00:01 1997

    现在注意了,有了mktime()函数,是不是我们可以操作现在之前的任何时间呢?你可以通过这种办法算

    出1945年8月15号是星期几吗?答案是否定的。因为这个时间在1970年1月1日之前,所以在大多数编译器

    中,这样的程序虽然可以编译通过,但运行时会异常终止。
      
       5.还知道了一个system()函数,是执行DOS命令的,system("某DOS命令");头文件是stdlib.h?windows.h

    展开全文
  • C++ 时间函数概述

    2018-09-27 22:03:36
    //延时函数在头文件<windows.h> 注:在c++里面也是.h。。。 t2=time(NULL); cout; }  输出: 1 2.clock_t clock(void); #include #include #include using namespace std; const int c=CLOCKS_...
  • 这里总结了C++中的几乎所有时间函数,包括计算程序运行时间的函数,获取当地时间的函数等等.
  • C/C++时间函数

    千次阅读 2017-08-15 09:10:18
    1、time函数 ...说明:返回从1970年1月1日的UTC时间从0时0分0妙算起到现在所经过的秒数。 #include #include int main(){ time_t timep; long seconds = time(&timep); printf("%l
  • c++时间函数性能对比

    千次阅读 2018-10-15 17:39:07
    uint64_t getCurrentTime1() {  struct timeb rawtime;  ftime(&amp;rawtime);  return rawtime.time * 1000 + rawtime.millitm; } uint64_t getCurrentTime2() {  return GetTickCount64();...uint64...
  • C/C++时间的操作也有许多值得大家注意的地方。最近,在技术群中有很多网友也多次问到过C++语言中对时间的操作、获取和显示等等的问题。下面,在这篇文章中,笔者将主要介绍在C/C++时间和日期的使用方法. 通过...
  • 关于C++时间函数

    2013-04-11 08:58:17
    C++时间函数返回的系统时间末尾是不是自带换行符?为什么写入文件的系统时间都自动换行了?而再次读取然后再写入又不自动换行了?
  • Linux下C/C++时间函数详解

    千次阅读 2018-01-08 16:35:01
    linux几种时间函数总结 一、linux时间函数总结  最近的工作中用到的时间函数比较频繁,今天抽时间总结一下,在linux下,常用的获取时间的函数有如下几个:  asctime, ctime, gmtime, localtime, ...
  • c/c++ 时间函数总结 linux

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

    2020-11-18 10:10:20
    (1)UTC/GMT:Coorainated Universal Time:它是一个标准,最主要的世界时间标准,其以原子时秒长为基础,在时刻上尽量接近于格林尼治平时,也即格林威治标准时间(Greenwich Mean Time,GMT),在大多数场合,UTC...
  • c/c++ 时间函数 localtime 坑

    千次阅读 2017-10-30 14:42:11
    localtime() 函数返回的数据 struct tm* 内存空间由其自己管理。  ​且连续调用时,第二次的调用会修改第一次的数据。  返回的时间为本地时区时间
  • C/C++时间函数使用方法(1)/C++对时间的操作也有许多值得大家注意的地方。最近,在技术群中有很多网友也多次问到过C++语言中对时间的操作、获取和显示等等的问题。下面,在这篇文章中,笔者将主要介绍在C/C++中时间和...
  • C/C++时间函数使用方法介绍(2)struct tm * localtime(const time_t * timer); 通过查阅MSDN,我们可以知道Microsoft C/C++ 7.0中时间点的值(time_t对象的值)是从1899年12月31日0时0分0秒到该时间点所经过的秒数,...
  • C++时间函数简单记录

    2012-07-30 18:36:12
    1,计时函数 clock_t clock ( void ); 返回从“开启这个程序进程”到“程序中调用clock()函数”时之间的时钟计时单元(clock tick)数。 头文件:或者 #ifndef _CLOCK_T_DEFINED typedef long clock_t; #...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,422
精华内容 4,568
关键字:

c++时间函数

c++ 订阅