精华内容
下载资源
问答
  • C语言time函数

    千次阅读 2016-11-02 16:18:42
    可以通过time()函数来获得计算机系统当前的日历时间(Calendar Time),处理日期时间的函数都是以本函数的返回值为基础进行运算。其原型为:time_t time(time_t * t);   如果你已经声明了参数t,你可以从参数t返回...
    在unix/Linux系统中,时间的表示方法是以1970年1月1日00:00:00所经过的秒数,使用基本系统数据类型time_t表示,在/usr/include下查找time_t类型的定义.

    可以通过time()函数来获得计算机系统当前的日历时间(Calendar Time),处理日期时间的函数都是以本函数的返回值为基础进行运算。其原型为:time_t time(time_t * t);
     
    如果你已经声明了参数t,你可以从参数t返回现在的日历时间,同时也可以通过返回值返回现在的日历时间,即从一个时间点(例如:1970年1月1日0时0分0秒)到现在此时的秒数。如果参数为空(NULL),函数将只通过返回值返回现在的日历时间。

    比如下面这个例子用来显示当前的日历时间:
    #include<stdio.h>
    #include<time.h>
    int main()
    {
    	time_t t; //time for seconds
    	int d;    //time for days
    	int y;    //time for years
    	t=time(NULL);
    	printf("The number of seconds since January 1,1970 is %d\n",t);
    	d=t/(3600*24);
    	printf("The number of days since January 1,1970 is %d\n",d);
    	y=d/365;
    	printf("The number of years since January 1,1970 is %d\n",y);
    	y=y+1970;
    	printf("This year is %d\n",y);
    	return 0;
    }

    可以得到运行结果:



    1. sys/types.h

    #define __need_timer_t

    #define __need_clockid_t

    #include <time.h>

     

    2.time.h

    typedef __time_t time_t;

    # include <bits/types.h>        /* This defines __time_t for us.  */

    3.bits/types.h

    __STD_TYPE __TIME_T_TYPE __time_t;      /* Seconds since the Epoch.  */

    # define __STD_TYPE             __extension__ typedef

    4.bits/typesizes.h

    #define __TIME_T_TYPE           __SLONGWORD_TYPE

     
    5. bits/types.h

    #define __SLONGWORD_TYPE        long int

     

    这里,基本就可以得出结论了:


    __extension__ typedef long int time_t

    则time_t类型的变量最大值为0x7fffffff

    代码:
    #include<stdio.h>
    #include<sys/types.h>
    #include<time.h>
    int main(void)
    {
            time_t cur_time=time(NULL), max_time=0x7fffffff,new_time=max_time+1;
            printf("Cur time: cur_time=0x%08x/n", cur_time);
            printf("/tLocal: %s", asctime(localtime(&cur_time)));
            printf("/tGMT  : %s/n", asctime(gmtime(&cur_time)));
            printf("Max time: max_time=0x%08x/n", max_time);
            printf("/tLocal: %s", asctime(localtime(&max_time)));
            printf("/tGMT  : %s/n", asctime(gmtime(&max_time)));
            printf("New time: new_time=0x%08x/n", new_time);
            printf("/tLocal: %s", asctime(localtime(&new_time)));
            printf("/tGMT  : %s/n", asctime(gmtime(&new_time)));
            return 0;
    }

    可以的到运行结果:


    从结果得出,32位的time_t最迟能表示到2038年1月19日 11:14:07(Asia/Shanghai时间) 或2038年1月19日 03:14:07(GMT时间),再过1秒,time_t数据将变为负数,变为1901年12月14日 04:51:44(本地时间),或1901年12月13日 20:45:52(GMT时间).



    C语言中time_t数据类型详细介绍

    包含文件:<time.h>
    #ifndef __TIME_T
    #define __TIME_T     /* 避免重复定义 time_t */
    typedef long     time_t;    /* 时间值time_t 为长整型的别名*/
    #endif
     
    既然time_t实际上是长整型(long int),用来保存从1970年1月1日0时0分0秒到现在时刻的秒数。到未来的某一天,从一个时间点(一般是1970年1月1日0时0分0秒)到那时的秒数(即日历时间)超出了长整形所能表示的数的范围怎么办?对time_t数据类型的值来说,它所表示的时间不能晚于2038年1月18日19时14分07秒。为了能够表示更久远的时间,一些编译器厂商引入了64位甚至更长的整形数来保存日历时间。比如微软在Visual C++中采用了__time64_t数据类型来保存日历时间,并通过_time64()函数来获得日历时间(而不是通过使用32位字的time()函数),这样就可以通过该数据类型保存3001年1月1日0时0分0秒(不包括该时间点)之前的时间。
     
    在time.h头文件中,我们还可以看到一些函数,它们都是以time_t为参数类型或返回值类型的函数:
     
    double difftime(time_t time1, time_t time0);
    time_t mktime(struct tm * timeptr);
    time_t time(time_t * timer);
    char * asctime(const struct tm * timeptr);
    char * ctime(const time_t *timer);
     
    此外,time.h还提供了两种不同的函数将日历时间(一个用time_t表示的整数)转换为我们平时看到的把年月日时分秒分开显示的时间格式tm:
     
    struct tm * gmtime(const time_t *timer);                                         
    struct tm * localtime(const time_t * timer);
     
    通过查阅MSDN,我们可以知道Microsoft C/C++ 7.0中时间点的值(time_t对象的值)是从1899年12月31日0时0分0秒到该时间点所经过的秒数,而其它各种版本的Microsoft C/C++和所有不同版本的Visual C++都是计算的从1970年1月1日0时0分0秒到该时间点所经过的秒数。


    C语言中的time函数<time.h>

    /* 
     * time.h
     * This file has no copyright assigned and is placed in the Public Domain.
     * This file is a part of the mingw-runtime package.
     * No warranty is given; refer to the file DISCLAIMER within the package.
     *
     * Date and time functions and types.
     *
     */
    
    #ifndef	_TIME_H_
    #define	_TIME_H_
    
    /* All the headers include this file. */
    #include <_mingw.h>
    
    #define __need_wchar_t
    #define __need_size_t
    #define __need_NULL
    #ifndef RC_INVOKED
    #include <stddef.h>
    #endif	/* Not RC_INVOKED */
    
    /*
     * Number of clock ticks per second. A clock tick is the unit by which
     * processor time is measured and is returned by 'clock'.
     */
    #define	CLOCKS_PER_SEC	((clock_t)1000)
    #define	CLK_TCK		CLOCKS_PER_SEC
    
    
    #ifndef RC_INVOKED
    
    /*
     * A type for storing the current time and date. This is the number of
     * seconds since midnight Jan 1, 1970.
     * NOTE: This is also defined in non-ISO sys/types.h.
     */
    #ifndef _TIME32_T_DEFINED
    typedef __int32 __time32_t;
    #define _TIME32_T_DEFINED
    #endif
    
    #ifndef __STRICT_ANSI__
    /* A 64-bit time_t to get to Y3K */
    #ifndef _TIME64_T_DEFINED
    typedef __int64 __time64_t;
    #define _TIME64_T_DEFINED
    #endif
    #endif
    
    #ifndef _TIME_T_DEFINED
    /* FIXME __STRICT_ANSI__ ! */
    #if __MSVCRT_VERSION__ >= 0x0800
    #ifndef _USE_32BIT_TIME_T
    typedef	__time64_t time_t;
    #else
    typedef	__time32_t time_t;
    #endif /* !_USE_32BIT_TIME_T */
    #else
    typedef	__time32_t time_t;
    #endif /* __MSVCRT_VERSION__ >= 0x0800 */
    #define _TIME_T_DEFINED
    #endif
    
    
    /*
     * A type for measuring processor time (in clock ticks).
     */
    #ifndef _CLOCK_T_DEFINED
    typedef	long	clock_t;
    #define _CLOCK_T_DEFINED
    #endif
    
    #ifndef _TM_DEFINED
    /*
     * A structure for storing all kinds of useful information about the
     * current (or another) time.
     */
    struct tm
    {
    	int	tm_sec;		/* Seconds: 0-59 (K&R says 0-61?) */
    	int	tm_min;		/* Minutes: 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 Jan. 1: 0-365 */
    	int	tm_isdst;	/* +1 Daylight Savings Time, 0 No DST,
    				 * -1 don't know */
    };
    #define _TM_DEFINED
    #endif
    
    #ifdef	__cplusplus
    extern "C" {
    #endif
    
    _CRTIMP clock_t __cdecl __MINGW_NOTHROW	clock (void);
    #if __MSVCRT_VERSION__ < 0x0800
    _CRTIMP time_t __cdecl __MINGW_NOTHROW	time (time_t*);
    _CRTIMP double __cdecl __MINGW_NOTHROW	difftime (time_t, time_t);
    _CRTIMP time_t __cdecl __MINGW_NOTHROW	mktime (struct tm*);
    #endif
    
    /*
     * These functions write to and return pointers to static buffers that may
     * be overwritten by other function calls. Yikes!
     *
     * NOTE: localtime, and perhaps the others of the four functions grouped
     * below may return NULL if their argument is not 'acceptable'. Also note
     * that calling asctime with a NULL pointer will produce an Invalid Page
     * Fault and crap out your program. Guess how I know. Hint: stat called on
     * a directory gives 'invalid' times in st_atime etc...
     */
    _CRTIMP char* __cdecl __MINGW_NOTHROW		asctime (const struct tm*);
    #if __MSVCRT_VERSION__ < 0x0800
    _CRTIMP char* __cdecl __MINGW_NOTHROW		ctime (const time_t*);
    _CRTIMP struct tm*  __cdecl __MINGW_NOTHROW	gmtime (const time_t*);
    _CRTIMP struct tm*  __cdecl __MINGW_NOTHROW	localtime (const time_t*);
    #endif
    
    _CRTIMP size_t __cdecl __MINGW_NOTHROW		strftime (char*, size_t, const char*, const struct tm*);
    
    #ifndef __STRICT_ANSI__
    
    extern _CRTIMP void __cdecl __MINGW_NOTHROW	_tzset (void);
    
    #ifndef _NO_OLDNAMES
    extern _CRTIMP void __cdecl __MINGW_NOTHROW	tzset (void);
    #endif
    
    _CRTIMP char* __cdecl __MINGW_NOTHROW	_strdate(char*);
    _CRTIMP char* __cdecl __MINGW_NOTHROW	_strtime(char*);
    
    /* These require newer versions of msvcrt.dll (6.10 or higher). */ 
    #if __MSVCRT_VERSION__ >= 0x0601
    _CRTIMP __time64_t __cdecl __MINGW_NOTHROW  _time64( __time64_t*);
    _CRTIMP __time64_t __cdecl __MINGW_NOTHROW  _mktime64 (struct tm*);
    _CRTIMP char* __cdecl __MINGW_NOTHROW _ctime64 (const __time64_t*);
    _CRTIMP struct tm*  __cdecl __MINGW_NOTHROW _gmtime64 (const __time64_t*);
    _CRTIMP struct tm*  __cdecl __MINGW_NOTHROW _localtime64 (const __time64_t*);
    #endif /* __MSVCRT_VERSION__ >= 0x0601 */
    
    /* These require newer versions of msvcrt.dll (8.00 or higher). */ 
    #if __MSVCRT_VERSION__ >= 0x0800
    _CRTIMP __time32_t __cdecl __MINGW_NOTHROW	_time32 (__time32_t*);
    _CRTIMP double	   __cdecl __MINGW_NOTHROW	_difftime32 (__time32_t, __time32_t);
    _CRTIMP double	   __cdecl __MINGW_NOTHROW	_difftime64 (__time64_t, __time64_t);
    _CRTIMP __time32_t __cdecl __MINGW_NOTHROW	_mktime32 (struct tm*);
    _CRTIMP __time32_t __cdecl __MINGW_NOTHROW	_mkgmtime32 (struct tm*);
    _CRTIMP __time64_t __cdecl __MINGW_NOTHROW	_mkgmtime64 (struct tm*);
    _CRTIMP char*	   __cdecl __MINGW_NOTHROW	_ctime32 (const __time32_t*);
    _CRTIMP struct tm* __cdecl __MINGW_NOTHROW	_gmtime32 (const __time32_t*);
    _CRTIMP struct tm* __cdecl __MINGW_NOTHROW	_localtime32 (const __time32_t*);
    #ifndef _USE_32BIT_TIME_T
    _CRTALIAS time_t	   __cdecl __MINGW_NOTHROW	time (time_t* _v)		  { return(_time64 (_v)); }
    _CRTALIAS double	   __cdecl __MINGW_NOTHROW	difftime (time_t _v1, time_t _v2) { return(_difftime64 (_v1,_v2)); }
    _CRTALIAS time_t	   __cdecl __MINGW_NOTHROW	mktime (struct tm* _v)		  { return(_mktime64 (_v)); }
    _CRTALIAS time_t	   __cdecl __MINGW_NOTHROW	_mkgmtime (struct tm* _v)	  { return(_mkgmtime64 (_v)); }
    _CRTALIAS char*		   __cdecl __MINGW_NOTHROW	ctime (const time_t* _v)	  { return(_ctime64 (_v)); }
    _CRTALIAS struct tm*	   __cdecl __MINGW_NOTHROW	gmtime (const time_t* _v)	  { return(_gmtime64 (_v)); }
    _CRTALIAS struct tm*	   __cdecl __MINGW_NOTHROW	localtime (const time_t* _v)	  { return(_localtime64 (_v)); }
    #else
    _CRTALIAS time_t	   __cdecl __MINGW_NOTHROW	time (time_t* _v)		  { return(_time32 (_v)); }
    _CRTALIAS double	   __cdecl __MINGW_NOTHROW	difftime (time_t _v1, time_t _v2) { return(_difftime32 (_v1,_v2)); }
    _CRTALIAS time_t	   __cdecl __MINGW_NOTHROW	mktime (struct tm* _v)		  { return(_mktime32 (_v)); }
    _CRTALIAS time_t	   __cdecl __MINGW_NOTHROW	_mkgmtime (struct tm* _v)	  { return(_mkgmtime32 (_v)); }
    _CRTALIAS char*		   __cdecl __MINGW_NOTHROW	ctime (const time_t* _v)	  { return(_ctime32 (_v)); }
    _CRTALIAS struct tm*	   __cdecl __MINGW_NOTHROW	gmtime (const time_t* _v)	  { return(_gmtime32 (_v)); }
    _CRTALIAS struct tm*	   __cdecl __MINGW_NOTHROW	localtime (const time_t* _v)	  { return(_localtime32 (_v)); }
    #endif /* !_USE_32BIT_TIME_T */
    #endif /* __MSVCRT_VERSION__ >= 0x0800 */
    
    
    /*
     * _daylight: non zero if daylight savings time is used.
     * _timezone: difference in seconds between GMT and local time.
     * _tzname: standard/daylight savings time zone names (an array with two
     *          elements).
     */
    #ifdef __MSVCRT__
    
    /* These are for compatibility with pre-VC 5.0 suppied MSVCRT. */
    extern _CRTIMP int* __cdecl __MINGW_NOTHROW	__p__daylight (void);
    extern _CRTIMP long* __cdecl __MINGW_NOTHROW	__p__timezone (void);
    extern _CRTIMP char** __cdecl __MINGW_NOTHROW	__p__tzname (void);
    
    __MINGW_IMPORT int	_daylight;
    __MINGW_IMPORT long	_timezone;
    __MINGW_IMPORT char 	*_tzname[2];
    
    #else /* not __MSVCRT (ie. crtdll) */
    
    #ifndef __DECLSPEC_SUPPORTED
    
    extern int*	_imp___daylight_dll;
    extern long*	_imp___timezone_dll;
    extern char**	_imp___tzname;
    
    #define _daylight	(*_imp___daylight_dll)
    #define _timezone	(*_imp___timezone_dll)
    #define _tzname		(*_imp___tzname)
    
    #else /* __DECLSPEC_SUPPORTED */
    
    __MINGW_IMPORT int	_daylight_dll;
    __MINGW_IMPORT long	_timezone_dll;
    __MINGW_IMPORT char*	_tzname[2];
    
    #define _daylight	_daylight_dll
    #define _timezone	_timezone_dll
    
    #endif /* __DECLSPEC_SUPPORTED */
    
    #endif /* not __MSVCRT__ */
    
    #endif	/* Not __STRICT_ANSI__ */
    
    #ifndef _NO_OLDNAMES
    
    #ifdef __MSVCRT__
    
    /* These go in the oldnames import library for MSVCRT. */
    __MINGW_IMPORT int	daylight;
    __MINGW_IMPORT long	timezone;
    __MINGW_IMPORT char 	*tzname[2];
    
    #else /* not __MSVCRT__ */
    
    /* CRTDLL is royally messed up when it comes to these macros.
       TODO: import and alias these via oldnames import library instead 
       of macros.  */
    
    #define daylight        _daylight
    /* NOTE: timezone not defined as macro because it would conflict with
       struct timezone in sys/time.h.
       Also, tzname used to a be macro, but now it's in moldname. */
    __MINGW_IMPORT char 	*tzname[2];
    
    #endif /* not __MSVCRT__ */
    
    #endif	/* Not _NO_OLDNAMES */
    
    #ifndef _WTIME_DEFINED
    /* wide function prototypes, also declared in wchar.h */
    #ifndef __STRICT_ANSI__
    #ifdef __MSVCRT__
    _CRTIMP wchar_t* __cdecl __MINGW_NOTHROW	_wasctime(const struct tm*);
    #if __MSVCRT_VERSION__ < 0x0800
    _CRTIMP wchar_t* __cdecl __MINGW_NOTHROW	_wctime(const time_t*);
    #endif
    _CRTIMP wchar_t* __cdecl __MINGW_NOTHROW	_wstrdate(wchar_t*);
    _CRTIMP wchar_t* __cdecl __MINGW_NOTHROW	_wstrtime(wchar_t*);
    #if __MSVCRT_VERSION__ >= 0x0601
    _CRTIMP wchar_t* __cdecl __MINGW_NOTHROW	_wctime64 (const __time64_t*);
    #endif
    #if __MSVCRT_VERSION__ >= 0x0800
    _CRTIMP wchar_t* __cdecl __MINGW_NOTHROW	_wctime32 (const __time32_t*);
    #ifndef _USE_32BIT_TIME_T
    _CRTALIAS wchar_t* __cdecl __MINGW_NOTHROW	_wctime (const time_t* _v) { return(_wctime64 (_v)); }
    #else
    _CRTALIAS wchar_t* __cdecl __MINGW_NOTHROW	_wctime (const time_t* _v) { return(_wctime32 (_v)); }
    #endif
    #endif /* __MSVCRT_VERSION__ >= 0x0800 */
    #endif /*  __MSVCRT__ */
    #endif /* __STRICT_ANSI__ */
    _CRTIMP size_t __cdecl __MINGW_NOTHROW		wcsftime (wchar_t*, size_t, const wchar_t*, const struct tm*);
    #define _WTIME_DEFINED
    #endif /* _WTIME_DEFINED */ 
    
    #ifdef	__cplusplus
    }
    #endif
    
    #endif	/* Not RC_INVOKED */
    
    #endif	/* Not _TIME_H_ */
    


    C语言中两种方式表示时间日期值time_t和struct tm类型的相互转换
    ①     使用gmtime函数或localtime函数将time_t类型的时间日期转换为struct tm类型:
    使用time函数返回的是一个long值,该值对用户的意义不大,一般不能根据其值确定具体的年、月、日等数据。gmtime函数可以方便的对time_t类型数据进行转换,将其转换为tm结构的数据方便数据阅读。
    gmtime函数的原型如下:
    struct tm *gmtime(time_t *timep);
    localtime函数的原型如下:
    struct tm *localtime(time_t *timep);
    将参数timep所指的time_t类型信息转换成实际所使用的时间日期表示方法,将结果返回到结构tm结构类型的变量。
    gmtime函数用来存放实际日期时间的结构变量是静态分配的,每次调用gmtime函数都将重写该结构变量。如果希望保存结构变量中的内容,必须将其复制到tm结构的另一个变量中。
    gmtime函数与localtime函数的区别:
    gmtime函数返回的时间日期未经时区转换,是UTC时间(又称为世界时间,即格林尼治时间)。
    localtime函数返回当前时区的时间,
    转换日期时间表示形式time_t类型转换为struct tm类型示例:
    #include <stdio.h>
    #include <time.h>
    #include<string.h>
    int main()
    {
        const char *wday[]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};/*指针字符数组*/
        time_t t;
        struct tm *p;
        t=time(NULL);/*获取从1970年1月1日零时到现在的秒数,保存到变量t中*/
        p=gmtime(&t); /*变量t的值转换为实际日期时间的表示格式*/
    	printf("%d年%02d月%02d日",(1900+p->tm_year), (1+p->tm_mon),p->tm_mday);
        printf(" %s ", wday[p->tm_wday]);
    	printf("%02d:%02d:%02d\n", p->tm_hour, p->tm_min, p->tm_sec);
        return 0;
    }
    
    //	time(&rawtime);  // 获取时间,以秒计,从1970年1月一日起算,存于rawtime
    //	timeinfo=localtime(&rawtime);  //转为当地时间,tm 时间结构
    //	printf("The current data/time is &s ",asctime(timeinfo));  //asctime() // 转为标准ASCII时间格式: 
    注意:p=gmtime(&t);此行若改为p=localtime(&t);则返回当前时区的时间
    输出结果:


    ②     使用mktime函数将struct tm类型的时间日期转换为time_t类型:
    表头文件
    #include <time.h>
    定义函数
    time_t mktime(strcut tm * timeptr);
    函数说明
    mktime()用来将参数timeptr所指的tm结构数据转换成从公元1970年1月1日0时0分0 秒算起至今的UTC时间所经过的秒数。
    返回值
    返回经过的秒数。
     
    日期转换为秒数示例:
    #include <stdio.h>
    #include <time.h>
    #include <cstdlib>
    int main()
    {
        time_t t;
        struct tm stm;
        printf("请输入日期时间值(按yyyy/mm/dd hh:mm:ss格式):");
        scanf("%d/%d/%d %d:%d:%d",&stm.tm_year,&stm.tm_mon,&stm.tm_mday,
            &stm.tm_hour,&stm.tm_min,&stm.tm_sec);
    stm.tm_year-=1900; /*年份值减去1900,得到tm结构中保存的年份序数*/
    stm.tm_mon-=1;    /*月份值减去1,得到tm结构中保存的月份序数*/
    t=mktime(&stm);  /* 若用户输入的日期时间有误,则函数返回值为-1*/
    if(-1==t)
    {
            printf("输入的日期时间格式出错!\n");
            exit(1);
    }
    printf("1970/01/01 00:00:00~%d/%02d/%02d %02d:%02d:%02d共%d秒\n",
        stm.tm_year+1900,stm.tm_mon,stm.tm_mday,
            stm.tm_hour,stm.tm_min,stm.tm_sec,t);
        return 0;
    }

    输出结果:


    其中出现的一些小问题:
    char *wday[]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};/*指针字符数组*/

    error:deprecated conversation from strig constant to 'char'

    当我们将一个character pointer variable 初始化成一个string literal的时候, 就会出现此类错误。

    解决方法:const  char *wday[]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};/*指针字符数组*/
    方案2:使用string:string x = "hello"; 
    方案3:将string literal转型为char* 的type: char* x = (char*)"hello";

    if(-1==t)
    {
            printf("输入的日期时间格式出错!\n");
            exit(1);
    }

    error: ‘exit’ was not declared in this scope 的解决方法

    解决方法:添加#include <cstdlib>


    最后贴一篇博客
    c语言中time函数的用法





    展开全文
  • C语言Time函数

    千次阅读 2013-04-30 14:14:48
    1、 time() 获取当前时间 time_t timer; time(&timer);  相当于 timer = time(NULL); 或 timer = time(0); 可用于随机数的生成。 srand( (unsigned)time(0)); 2、localtime() 把一个时间戳转换 年月日...

    1、 time() 获取当前时间

    time_t timer;

    time(&timer); 

    相当于 timer = time(NULL); 或 timer = time(0);

    可用于随机数的生成。

    srand( (unsigned)time(0));


    2、localtime() 把一个时间戳转换 年月日表示格式

    3、ctime()    把一个 时间戳转换为  年月日表示的字符串

    char* ctime (const time_t * timer);


    	struct tm * date;
    	time_t now;
    	time(&now);
    	date = localtime(&now);
    
    	//ctime() 演示
    	char * datestr;
    	datestr = ctime(&now);
    
    	//mktime 演示
    	time_t resTm = mktime(date);
    
    	//strftime
    
    
    	cout << now << endl;
    	cout << date->tm_year << " " << date->tm_mon << " " << date->tm_mday << endl;
    	cout << datestr << endl;
    	cout << resTm << endl;




    4 differtime 返回相隔的时(以秒为单位)

    double difftime (time_t end, time_t beginning);

    5  strftime()

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

    把 timeptr 所指向的 时间格式化显示, 放在 pstr中。

    specifier Replaced by Example
    %a Abbreviated weekday name * Thu
    %A Full weekday name * Thursday
    %b Abbreviated month name * Aug
    %B Full month name * August
    %c Date and time representation * Thu Aug 23 14:55:02 2001
    %C Year divided by 100 and truncated to integer (00-99) 20
    %d Day of the month, zero-padded (01-31) 23
    %D Short MM/DD/YY date, equivalent to %m/%d/%y 08/23/01
    %e Day of the month, space-padded ( 1-31) 23
    %F Short YYYY-MM-DD date, equivalent to %Y-%m-%d 2001-08-23
    %g Week-based year, last two digits (00-99) 01
    %G Week-based year 2001
    %h Abbreviated month name * (same as %b) Aug
    %H Hour in 24h format (00-23) 14
    %I Hour in 12h format (01-12) 02
    %j Day of the year (001-366) 235
    %m Month as a decimal number (01-12) 08
    %M Minute (00-59) 55
    %n New-line character ('\n')
    %p AM or PM designation PM
    %r 12-hour clock time * 02:55:02 pm
    %R 24-hour HH:MM time, equivalent to %H:%M 14:55
    %S Second (00-61) 02
    %t Horizontal-tab character ('\t')
    %T ISO 8601 time format (HH:MM:SS), equivalent to %H:%M:%S 14:55:02
    %u ISO 8601 weekday as number with Monday as 1 (1-7) 4
    %U Week number with the first Sunday as the first day of week one (00-53) 33
    %V ISO 8601 week number (00-53) 34
    %w Weekday as a decimal number with Sunday as 0 (0-6) 4
    %W Week number with the first Monday as the first day of week one (00-53) 34
    %x Date representation * 08/23/01
    %X Time representation * 14:55:02
    %y Year, last two digits (00-99) 01
    %Y Year 2001
    %z ISO 8601 offset from UTC in timezone (1 minute=1, 1 hour=100)
    If timezone cannot be termined, no characters
    +100
    %Z Timezone name or abbreviation *
    If timezone cannot be termined, no characters
    CDT
    %% % sign %
    * The specifiers marked with an asterisk (*) are locale-dependent.
    Note: Yellow rows indicate specifiers and sub-specifiers introduced by C99. Since C99, two locale-specific modifiers can also be inserted between the percentage sign (%) and the specifier proper to request an alternative format, where applicable:
    Modifier Meaning Applies to
    E Uses the locale's alternative representation %Ec %EC %Ex %EX %Ey %EY
    O Uses the locale's alternative numeric symbols %Od %Oe %OH %OI %Om %OM %OS %Ou %OU %OV %Ow %OW %Oy



    展开全文
  • C语言 time 函数使用

    2020-08-02 19:07:09
    C语言time 函数 使用time函数需要包含头文件 #include <time.h> gmtime() 和localtime() 函数原型 关于时区 可参考以下链接 百度百科 https://baike.baidu.com/item/%E6%97%B6%E5%B7%AE/1305648?fr=aladdin ...

    C语言time 函数

    使用time函数需要包含头文件 #include <time.h>
    gmtime() 和localtime() 函数原型

    关于时区
    可参考以下链接
    百度百科
    https://baike.baidu.com/item/%E6%97%B6%E5%B7%AE/1305648?fr=aladdin

    时间网
    http://www.shijian.cc/shiqu/

    tm *gmtime( const time_t * _time)   
      //获取世界标准时间格林威治时间 UTC(+0)
    tm *localtime( const time_t * _time)
     //获取本地时间,会随着本地时间时区的更改改变
    

    gmtime和locatime 计算时间以1970年为基点,同时计算时间是以秒计算的。time_t 实际上是 typedef long long time_t

    localtime

     time_t now = 0;   
     tm *localnow = localtime( &now);
     std::cout << localnow -> tm_hour << std::endl;
    

    实例中,设置now 值为0;在localtime()函数中,就表示1997年1月1 号的0点0分0秒 。
    但由于时区影响,输出的时间是不同的。这时候将系统时间时区重新后,在启动程序,输出值是变化的。北京时间的话,输出应该是8。
    在这里插入图片描述

     time_t now = time(NULL);     或者  time_t t ; time(&t);
     tm *localnow = localtime( &now);
     std::cout << localnow -> tm_hour << std::endl;
    

    此时t 为time()函数返回的1970 年开始到现在的秒数。并通过localtime() 函数将相应结果赋值给结构体变量localnow, 通过结构体变量localnow 内的变量可以得出本地时间。
    或者直接使用 char asctime( const tm _time)函数来直接获取本地时间。

     time_t now = 0;   
     tm *localnow = gmtime( &now);    //获取的是格林威治时间 (UTC+0)
     std::cout << localnow -> tm_hour << std::endl;   //输出值为零
    

    不管本地时区,只返回格林威治时间。所以输出的是0;

    结构体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; /
    一年中的第几天 1 - [0,365] /
    int tm_isdst; /
    夏令时标志 */
    };

    总结

    gmtime() 和localtime() 将time_t 类型值,当作秒计算从1970 年开始的时间计算,并将相应值赋给结构体 tm 。可以通过结构体变量去访问相应的结果。

    展开全文
  • c语言time函数库详解

    2010-09-06 18:10:52
    C语言知识详解,c语言time函数库详解
  • c语言time函数怎么使用In this article, we’ll take a look at using the time() function in C/C++. 在本文中,我们将研究在C / C ++中使用time()函数。 The time() function is a useful utility function ...

    c语言time函数怎么使用

    In this article, we’ll take a look at using the time() function in C/C++.

    在本文中,我们将研究在C / C ++中使用time()函数。

    The time() function is a useful utility function that we can use to measure the elapsed time of our program.

    time()函数是一个有用的实用程序函数,可用于测量程序的经过时间。

    Let’s look at how we can use this function, using some simple examples!

    让我们来看一些简单的例子,看看如何使用此功能!



    C / C ++中time()函数的基本语法 (Basic Syntax of the time() function in C/C++)

    This function belongs to the header file <time.h>, so we must include this before calling time().

    该函数属于头文件<time.h> ,因此在调用time()之前必须包含此文件。

    
    #include <time.h>
    time_t time(time_t *tloc);
    

    This takes in a pointer to a time_t datatype and returns the time elapsed since 00:00:00 UTC, January 1, 1970.

    这将获取一个指向time_t数据类型的指针,并返回从1970年1月1日UTC 00:00:00开始经过的时间。

    The time value returned is in seconds, so you must make suitable conversions from it.

    返回的时间值以秒为单位,因此您必须从中进行适当的转换。

    If tloc is not a null pointer, the returned value is also stored in the object pointed to by second.

    如果tloc 不是空指针,则返回的值也存储在second指向的对象中。

    Otherwise, if tloc is NULL, the return value is not stored anywhere.

    否则,如果tlocNULL ,则返回值不会存储在任何地方。

    Let’s look at some simple examples now.

    现在让我们看一些简单的例子。

    在C / C ++中使用time()–一些示例 (Using time() in C/C++ – Some Examples)

    Let’s first look at the case when tloc is a NULL pointer.

    首先让我们看一下tloc是NULL指针的情况。

    
    #include <stdio.h>
    #include <time.h>
    
    int main() {
        time_t num_seconds = time(NULL); // Passing NULL to time()
        printf("Since 1st January 1970 UTC, No. of seconds = %d, No. of days = %d", (int)num_seconds, (int)num_seconds/86400);
        return 0;
    }
    

    Output

    输出量

    
    Since 1st January 1970 UTC, No. of seconds = 1592317455, No. of days = 18429
    

    As of the time of writing (June 16 2020), this is indeed true!

    截至撰写本文时(2020年6月16日),确实如此!

    Now, let’s go to the second case, when tloc is not NULL.

    现在,让我们转到第二种情况,即tloc不为NULL时。

    In this case, since the return value will be stored to the pointer location, there is no need to assign it separately!

    在这种情况下,由于返回值将存储在指针位置,因此无需单独分配它!

    
    #include <stdio.h>
    #include <time.h>
    
    int main() {
        time_t tloc;
        time(&tloc); // Storing the return value to tloc
        printf("Since 1st January 1970 UTC, No. of seconds = %d, No. of days = %d", (int)tloc, (int)tloc/86400);
        return 0;
    }
    

    This will give a similar output as before.

    这将提供与以前相似的输出。



    结论 (Conclusion)

    In this article, we learned about using the time() function in C / C++, to get the time elapsed since the first epoch.

    在本文中,我们学习了如何在C / C ++中使用time()函数来获取自第一个时期以来所经过的时间。

    For more content on C and C++, do go through our tutorial section on C programming!

    有关C和C ++的更多内容,请阅读我们有关C编程的教程部分

    参考资料 (References)



    翻译自: https://www.journaldev.com/41447/time-function-in-c-plus-plus

    c语言time函数怎么使用

    展开全文
  • C语言time函数详解

    2012-06-10 19:09:42
    很多情况下都会用到time函数,但很多时候都不是很理解原理。 从网络上整理成文档,方便使用。
  • 函数原型: struct tm *localtime(const time_t *timer) 函数功能: 返回一个以tm结构表达的机器时间信息 函数返回: 以tm结构表达的时间,结构tm定义如下: 复制代码 1 struct tm { 2 int tm_sec; 3 i...
  • C语言time函数资料

    2011-07-17 22:16:12
    C/C++中的日期和时间 头文件 time.h 函数用途 函数名 得到处理器时间 clock 得到时间差 difftime 设置时间 mktime 得到时间 time 得到以ASCII码表示的时间 asctime 得到字符串表示的时间 ctime
  • 计算时间差,标准C提供了difftime函数,它的原型:double difftime( time_t timer1,time_t timer0);下面的这段代码编译没问题#include int _tmain(int argc, _TCHAR* argv[]){time_t* start, *finish;start=NULL;...
  • C语言time()函数的用法

    万次阅读 多人点赞 2018-07-10 16:12:33
    time()函数C语言标准库stdlib中的函数。因此要使用time(),必须在程序中包含<time.h>文件。 下面是从<time.h>文件中找到的函数声明: time_t time(time_t *t) time(time_t *t...
  • C语言time函数

    2016-01-27 15:48:00
    C语言time函数 在学习LinuxC时遇到了关于时间函数的问题,找到了这篇文章,希望能对有所需要的人有所帮助。  C/C++中的日期和时间  头文件 time.h  函数用途函数名  得到处理器时间 clock  得到时间差 ...
  • c语言使用time函数

    千次阅读 2018-09-15 10:31:16
    看了两遍博客是关于C语言时间函数的, 分别是https://blog.csdn.net/wangluojisuan/article/details/7045592 和https://www.cnblogs.com/caolisong/archive/2007/04/11/709732.html。 简单写了个自己的例子,以...
  • 常见的时间函数time( )、ctime( )、gmtime( )、localtime( )、mktime( )、asctime( )、difftime( )、gettimeofday( )、settimeofday( ) 其中,gmtime和localtime函数差不多,只是localtime函数会按照时区输出,而...
  • C语言time函数和difftime函数

    万次阅读 多人点赞 2016-02-23 09:36:19
    C语言函数time() 头文件:#include 定义函数time_t time(time_t *t); 函数说明:此函数会返回从公元 1970 年1 月1 日的UTC 时间从0 时0 分0 秒算起到现在所经过的秒数。如果t 并非空指针的话,此函数也...
  • 总结:time_t time(time_t *timer);返回以格林尼治时间(GMT)为标准,从1970年1月1日... time函数只能精确到秒级。clock_t clock(void);返回进程启动到调用函数时所经过的CPU时钟计时单元(clocktick)数,在MSDN中称之...
  • C语言time函数

    2016-03-22 16:35:00
    #include<time.h> int fun() { clock_t start,finish; double time; start = clock(); /*测试时间的代码*/ finish = clock(); time = (double)(finish - start)/CLOCKS_PER_SEC;/...
  • C语言随机函数

    千次阅读 2019-01-03 09:42:44
    C语言随机函数 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&... //time函数time.h库 printf("%c\n",rand()%26+'A');//printf函数 stdio.h库 srand((...
  • c语言time函数详解

    千次阅读 2014-08-19 09:12:25
    c语言中有关时间、日期等的函数详解

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,509
精华内容 1,003
关键字:

c语言time函数

c语言 订阅