linux 年份函数加一年_oracle时间函数一年前 - CSDN
  • Linux的时间函数

    千次阅读 2014-03-14 16:05:19
    Linux的时间函数  一、时间相关说明 格林威治时间表示0时区的标准时间。其他时区的时间和此标准时间均有时间差。UTC(Universal Time Coordinated)是世界协调时间,是格林威治时间在互联网中的表示方法 二、...

    Linux的时间函数

     一、时间相关说明

    格林威治时间表示0时区的标准时间。其他时区的时间和此标准时间均有时间差。UTC(Universal Time Coordinated)是世界协调时间,是格林威治时间在互联网中的表示方法

    二、标准C语言时间函数

    1、time(取得本地目前的时间秒数)

    #include<time.h>

    time_t time(time_t *t);

    函数说明  此函数会返回从公元1970年1月1日的UTC时间从0时0分0秒(Epoch,linux纪元)算起到现在所经过的秒数。如果t 并非空指针的话,此函数也会将返回值存到t指针所指的内存。

    返回值  成功则返回秒数,失败则返回((time_t)-1)值,错误原因存于errno中。

    time_t 定义为long int

    范例  #include<time.h>

    mian()

    {

    long int seconds= time((time_t*)NULL);

    printf(“%d\n”,seconds);

    }

    执行  9.73E+08

    2、gmtime(根据本地时间取得目前的UTC时间)

    #include<time.h>

    struct tm*gmtime(const time_t*timep);

    函数说明  gmtime()将参数timep 所指的time_t 结构中的信息转换成真实世界所使用的时间日期表示方法,然后将结果由结构tm返回。

    结构tm的定义为

    struct tm

    {

    int tm_sec;

    int tm_min;

    int tm_hour;

    int tm_mday;

    int tm_mon;

    int tm_year;

    int tm_wday;

    int tm_yday;

    int tm_isdst;

    };

    int tm_sec 代表目前秒数,正常范围为0-59,但允许至61秒

    int tm_min 代表目前分数,范围0-59

    int tm_hour 从午夜算起的时数,范围为0-23

    int tm_mday 目前月份的日数,范围01-31

    int tm_mon 代表目前月份,从一月算起,范围从0-11

    int tm_year 从1900 年算起至今的年数

    int tm_wday 一星期的日数,从星期一算起,范围为0-6

    int tm_yday 从今年1月1日算起至今的天数,范围为0-365

    int tm_isdst 日光节约时间的旗标

    此函数返回的时间日期未经时区转换,而是UTC时间。

    返回值  返回结构tm代表目前UTC 时间

    范例  #include <time.h>

    main(){

    char *wday[]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};

    time_t timep;

    struct tm *p;

    time(&timep);

    p=gmtime(&timep);

    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);

    }

    执行  2000/10/28 Sat 8:15:38

    3、localtime(取得当地目前UTC时间和日期) 

    #include<time.h>

    struct tm *localtime(const time_t * timep);

    函数说明  localtime()将参数timep所指的time_t结构中的信息转换成真实世界所使用的时间日期表示方法,然后将结果由结构tm返回。结构tm的定义请参考gmtime()。此函数返回的时间日期已经转换成当地时区。

    返回值  返回结构tm代表目前的当地时间。

    范例  #include<time.h>

    main(){

    char *wday[]={“Sun”,”Mon”,”Tue”,”Wed”,”Thu”,”Fri”,”Sat”};

    time_t timep;

    struct tm *p;

    time(&timep);

    p=localtime(&timep); /*取得当地时间*/

    printf (“%d%d%d ”, (1900+p->tm_year),( l+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);

    }

    执行  2000/10/28 Sat 11:12:22

    4、ctime(将时间和日期以字符串格式表示) 

    #include<time.h>

    char *ctime(const time_t *timep);

    函数说明  ctime()将参数timep所指的time_t结构中的信息转换成真实世界所使用的时间日期表示方法,然后将结果以字符串形态返回。此函数已经由时区转换成当地时间,字符串格式为“Wed Jun 30 21 :49 :08 1993\n”。若再调用相关的时间日期函数,此字符串可能会被破坏。

    返回值  返回一字符串表示目前当地的时间日期。

    范例  #include<time.h>

    main()

    {

    time_t timep;

    time (&timep);

    printf(“%s”,ctime(&timep));

    }

    执行  Sat Oct 28 10 : 12 : 05 2000

    5、asctime(将时间和日期以字符串格式表示) 

    #include<time.h>

    char * asctime(const struct tm * timeptr);

    函数说明  asctime()将参数timeptr所指的tm结构中的信息转换成真实世界所使用的时间日期表示方法,然后将结果以字符串形态返回。此函数已经由时区转换成当地时间,字符串格式为:“Wed Jun 30 21:49:08 1993\n”

    返回值  若再调用相关的时间日期函数,此字符串可能会被破坏。此函数与ctime不同处在于传入的参数是不同的结构。

    附加说明  返回一字符串表示目前当地的时间日期。

    范例  #include <time.h>

    main()

    {

    time_t timep;

    time (&timep);

    printf(“%s”,asctime(gmtime(&timep)));

    }

    执行  Sat Oct 28 02:10:06 2000

    6、mktime(将时间结构数据转换成经过的秒数) 

    #include<time.h>

    time_t mktime(strcut tm * timeptr);

    函数说明  mktime()用来将参数timeptr所指的tm结构数据转换成从公元1970年1月1日0时0分0 秒算起至今的UTC时间所经过的秒数。

    返回值  返回经过的秒数。

    范例  /* 用time()取得时间(秒数),利用localtime()

    转换成struct tm 再利用mktine()将struct tm转换成原来的秒数*/

    #include<time.h>

    main()

    {

    time_t timep;

    strcut tm *p;

    time(&timep);

    printf(“time() : %d \n”,timep);

    p=localtime(&timep);

    timep = mktime(p);

    printf(“time()->localtime()->mktime():%d\n”,timep);

    }

    执行  time():974943297

    time()->localtime()->mktime():974943297

    设置系统时间

    标准C库中只有获取系统时间的API,好像还没有设置系统时间的API,本文将谈谈如何在linux和windows平台设置系统时间,最后给出一个与平台无关的设置系统时间的封闭函数。

    Linux下设置系统时间:

    1.Linux下设置系统时间的函数有好几个,先来看看最常用的stime()函数,这个函数只能精确到秒。

    #define _SVID_SOURCE /*如果你使用的是glib2的话,必须先定义这个宏才能使用*/

    #include <time.h>

    int stime(time_t *t);

    参数说明:

    t是以秒为单位的时间值,从GMT1970年1月1日0时0分0秒开始计算。

    返回值:

    成功返回0,错误返回-1,errno错误码,EFAULT表示传递的参数错误,如时间值是无效的值,EPERM表示权限不够,注意只有root用户才有修改系统时间的权限。如果要让普通程序修改系统时间,可以先切换到root用户操作,修改完成后,再切换到普通用户,或者用命令chmod +s给执行文件加上root用户的权限。

    2.linux是如何管理时间的?

    在系统启动时,Linux操作系统将时间从CMOS中读到系统时间变量中,以后修改时间通过修改系统时间实现。为了保持系统时间与CMOS时间的一致性,Linux每隔11分钟会将系统时间写入CMOS,同步时间。从这可以看出,获取系统时间有两个途径,一种是从CMOS中读,一种是从系统中读,但修改时间却只有一种,即修改linux系统中的时间,而修改CMOS中的时间是无效的,因为CMOS中的时间会被定时重写掉。另外还有一点要注意,修改了系统时间并不是马上生效的,假如你修改了系统时间并马上关机,再开机的时候,时间还是原来的,因为修改的时间还没有来得及写入CMOS中。

    3.通过settimeofday()函数来设置系统时间,这个函数设置的精度可以精确到微秒。

    #include <sys/time.h>

    int settimeofday(const struct timeval *tv , const struct timezone *tz);

    struct timeval {

        time_t      tv_sec;     /* seconds */

        suseconds_t tv_usec;    /* microseconds */

    };

    struct timezone {

        int tz_minuteswest;     /* minutes west of Greenwich */

        int tz_dsttime;         /* type of DST correction */

    };

    tz参数为时区,时区结构中tz_dsttime在linux中不支持,应该置为0,通常将参数tz设置为NULL,表示使用当前系统的时区。该函数是glib中的,但在mingw中没有实现。

    该函数返回值与stime()一样,同样也需要root权限。

    4.设置CMOS时间,其实它是通过RTC(Real-time clock)设备驱动来完成的,你可以用ioctl()函数来设置时间,当然也可以通过操作/dev/rtc设备文件,在此就不详细说明了。

    二、windows下设置系统时间

    1.设置当前时区的时间

    #include <winbase.h>

    BOOL SetLocalTime(const SYSTEMTIME* lpSystemTime);

    typedef struct _SYSTEMTIME {  // st 

        WORD wYear;

        WORD wMonth; //月份从1开始

        WORD wDayOfWeek; //SetLocalTime()不使用这个参数

        WORD wDay;

        WORD wHour;

        WORD wMinute;

        WORD wSecond;

        WORD wMilliseconds;

    } SYSTEMTIME;

    函数成功返回非零,失败返回零。注意要求调用进程必需有SE_SYSTEMTIME_NAME权限。

    2.另外还有一个函数SetSystemTime(),它的参数与SetLocalTime一样,只不过以UTC时区为基准的。

    BOOL SetSystemTime(const SYSTEMTIME* lpSystemTime);

    <!--[if !supportLists]-->二、<!--[endif]-->一个封装的设置系统时间的函数

    //设置成功返回true,否则返回false

           bool set_local_time(struct tm& t)

    {

    #ifdef _WIN32

           SYSTEMTIME st;

           memset(&st, 0, sizeof(SYSTEMTIME));

           st.wYear = t.tm_year + 1970; //注意struct tm结构中的年是从1970年开始的计数

           st.wMonth = t.tm_mon + 1; //注意struct tm结构中的月份是从0开始的

           st.wDay = t.tm_mday;

           st.wHour = t.tm_hour;

           st.wMinute = t.tm_min;

           st.wSecond = t.tm_sec;

           if(!SetLocalTime(&st))

                  return true;

                  else

                         return false;

           #else

                  //将struct tm结构时间转换成GMT时间time_t

                  struct time_t st;

                  st = mktime(&t);

                  if(st==-1)

                         return false;

                  if(!stime(st))

                         return true;

                  else

                         return false;

    #endif

    }

     

    三、linux系统时间函数

    1、gettimeofday(取得目前的时间) 

    #include <sys/time.h>

    #include <unistd.h>

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

    函数说明  gettimeofday()会把目前的时间有tv所指的结构返回,当地时区的信息则放到tz所指的结构中。

    timeval结构定义为:

    struct timeval{

    long tv_sec;   /*秒,也是从linux纪元时间开始的秒数,和用time函数获取的数据一致*/

    long tv_usec; /*微秒*/

    };

    timezone 结构定义为:

    struct timezone{

    int tz_minuteswest; /*和Greenwich 时间差了多少分钟*/

    int tz_dsttime; /*日光节约时间的状态*/

    };

    上述两个结构都定义在/usr/include/sys/time.h。tz_dsttime 所代表的状态如下

    DST_NONE /*不使用*/

    DST_USA /*美国*/

    DST_AUST /*澳洲*/

    DST_WET /*西欧*/

    DST_MET /*中欧*/

    DST_EET /*东欧*/

    DST_CAN /*加拿大*/

    DST_GB /*大不列颠*/

    DST_RUM /*罗马尼亚*/

    DST_TUR /*土耳其*/

    DST_AUSTALT /*澳洲(1986年以后)*/

    返回值  成功则返回0,失败返回-1,错误代码存于errno。附加说明EFAULT指针tv和tz所指的内存空间超出存取权限。

    范例  #include<sys/time.h>

    #include<unistd.h>

    main(){

    struct timeval tv;

    struct timezone tz;

    gettimeofday (&tv , &tz);

    printf(“tv_sec; %d\n”, tv,.tv_sec) ;

    printf(“tv_usec; %d\n”,tv.tv_usec);

    printf(“tz_minuteswest; %d\n”, tz.tz_minuteswest);

    printf(“tz_dsttime, %d\n”,tz.tz_dsttime);

    }

    执行  tv_sec: 974857339

    tv_usec:136996

    tz_minuteswest:-540

    tz_dsttime:0

     

    2、settimeofday(设置目前时间)

    #include<sys/time.h>

    #include<unistd.h>

    int settimeofday ( const struct timeval *tv,const struct timezone *tz);

     

    函数说明  settimeofday()会把目前时间设成由tv所指的结构信息,当地时区信息则设成tz所指的结构。详细的说明请参考gettimeofday()。注意,只有root权限才能使用此函数修改时间。

     

    返回值  成功则返回0,失败返回-1,错误代码存于errno。

    错误代码  EPERM 并非由root权限调用settimeofday(),权限不够。

    EINVAL 时区或某个数据是不正确的,无法正确设置时间。

    3、clock_gettime(获取指定时钟的时间值)

    #include <time.h>

    int clock_gettime( clockid_t clock_id,struct timespec * tp );

    说明:clock_id指定要获取时间的时钟,根据Posix的指定可以是以下值:

    CLOCK_REALTIME

    Systemwide realtime clock.

     

    CLOCK_MONOTONIC

    Represents monotonic time. Cannot be set.

     

    CLOCK_PROCESS_CPUTIME_ID

    High resolution per-process timer.

     

    CLOCK_THREAD_CPUTIME_ID

    Thread-specific timer.

     

    CLOCK_REALTIME_HR

    High resolution version of CLOCK_REALTIME.

     

    CLOCK_MONOTONIC_HR

    High resolution version of CLOCK_MONOTONIC.

     

    struct timespec {

    time_t tv_sec;        /* seconds */

    long  tv_nsec;       /* nanoseconds 纳秒*/

    };

     

    4、adjtimex(tune kernel clock)

    #include <sys/timex.h>

    int adjtimex(struct timex *buf);

    说明:

    Linux  uses  David L. Mills' clock adjustment algorithm (see RFC 1305).The system call adjtimex() reads and optionally sets adjustment parame-ters  for  this  algorithm.   It  takes a pointer to a timex structure,updates kernel parameters from  field  values,  and  returns  the  same structure  with  current  kernel values.  This structure is declared as follows:

    struct timex {

    int modes;           /* mode selector */

    long offset;         /* time offset (usec) */

    long freq;           /* frequency offset (scaled ppm) */

    long maxerror;       /* maximum error (usec) */

    long esterror;       /* estimated error (usec) */

    int status;          /* clock command/status */

    long constant;       /* pll time constant */

    long precision;      /* clock precision (usec) (read only) */

    long tolerance;      /* clock frequency tolerance (ppm) (read only) */

    struct timeval time; /* current time (read only) */

    long tick;           /* usecs between clock ticks */

    };

    The modes field determines which parameters, if any, to  set.   It  may contain a bitwise-or combination of zero or more of the following bits:

     

    #define ADJ_OFFSET            0x0001 /* time offset */

    #define ADJ_FREQUENCY         0x0002 /* frequency offset */

    #define ADJ_MAXERROR          0x0004 /* maximum time error */

    #define ADJ_ESTERROR          0x0008 /* estimated time error */

    #define ADJ_STATUS            0x0010 /* clock status */

    #define ADJ_TIMECONST         0x0020 /* pll time constant */

    #define ADJ_TICK              0x4000 /* tick value */

    #define ADJ_OFFSET_SINGLESHOT 0x8001 /* old-fashioned adjtime() */ 

    Ordinary users are restricted to a zero value for mode.  Only the supe-ruser may set any parameters. 

    RETURN VALUE

    On success, adjtimex() returns the clock state: 

    #define TIME_OK   0 /* clock synchronized */

    #define TIME_INS  1 /* insert leap second */

    #define TIME_DEL  2 /* delete leap second */

    #define TIME_OOP  3 /* leap second in progress */

    #define TIME_WAIT 4 /* leap second has occurred */

    #define TIME_BAD  5 /* clock not synchronized */ 

    On failure, adjtimex() returns -1 and sets errno. 

    ERRORS

    EFAULT

    buf does not point to writable memory. 

    EINVAL

    An attempt is made to set buf.offset to a value outside the range -131071 to +131071, or to set buf.status to a value other than those listed above, or to set buf.tick to a value outside the range 900000/HZ to 1100000/HZ, where HZ is the system  timer interrupt frequency. 

    EPERM

    buf.mode is non-zero and the caller does not have sufficient privilege.Under Linux the CAP_SYS_TIME capability is required.

    CONFORMING TO

    adjtimex() is Linux specific and should not be used in programs intended to be portable. See adjtime(3) for a more portable, but less flexible, method of adjusting the system clock.


    转自:http://blog.chinaunix.net/uid-20551291-id-1927005.html

    展开全文
  • 计算一年有多少秒

    千次阅读 2018-04-15 17:52:04
    //输入一个年份,判断这一年有多少秒; //分别判断平年和闰年 //闰年能被4整除并且不能被100整除或者可以被400整除 #include&lt;iostream&gt; using namespace std; void second(int year) { if((year%4 ==...
    //输入一个年份,判断这一年有多少秒;
    //分别判断平年和闰年
    //闰年能被4整除并且不能被100整除或者可以被400整除
    #include<iostream>
    using namespace std;
    void second(int year)
    {
    	if((year%4 == 0 && year%100 != 0) ||year%400 == 0)//判断是否是闰年
    	{
    		int n = 366*12*3600;
    		cout<<year<<" "<<"have"<<" "<<n<<" "<<"second"<<endl;
    	}
    	else
    	{
    		int n = 365*12*3600;
    		cout<<year<<" "<<"have"<<" "<<n<<" "<<"second"<<endl;
    	}
    }
    void main()
    {
    	while(1)
    	{
    		int year;
    		cout<<"please input one year:";
    		scanf("%d",&year);
    		if(year == -1)//输入-1程序退出
    		{
    			cout<<"quit!"<<endl;
    			break;
    		}
    		second(year);
    	}
    }

    展开全文
  • linux下的c语言系统函数调用

    千次阅读 2018-11-05 23:36:44
    4.linux下的系统函数的使用 c语言 4.1数学函数的使用 1pow函数 2.exp函数 3.log函数 4.rand()随机数函数 4.2字符函数的使用 4.3系统时间与日期函数的使用 系统时间 时间间隔 4.4环境控制函数   4.linux...

    目录

    4.linux下的系统函数的使用 c语言

    4.1数学函数的使用

    1pow函数

    2.exp函数

    3.log函数

    4.rand()随机数函数

    4.2字符函数的使用

    4.3系统时间与日期函数的使用

    系统时间

    时间间隔

    4.4环境控制函数


     

    4.linux下的系统函数的使用 c语言

    4.1数学函数的使用

    pow(x,y)  //x的y次方 
    exp(x)      //e的x次方
    log(x)      //lnx
    log10(x)  //lg(x)   
    以上返回值参数全double

    1pow函数

    #include<stdio.h>
    #include<math.h>
    int main(){
    	double answer,x,y;
    	scanf("%lf %lf",&x,&y);
    	answer=pow(x,y);
    	printf("%lf的%lf次方等于%lf\n",x,y,answer);
    	return 0;
    }

     

    2.exp函数

    #include<stdio.h>
    #include<math.h>
    int main(){
    	double answer,x;
    	scanf("%lf",&x);
    	answer=exp(x);
    	printf("e的%lf次方等于%lf\n",x,answer);
    	return 0;
    }

     

    3.log函数

    #include<stdio.h>
    #include<math.h>
    int main(){
    	double answer1,answer2,x,y;
    	scanf("%lf %lf",&x,&y);
    	answer1=log(x);//2.718281828
    	answer2=log10(y);//10
    	printf("log(%lf)=%lf\n",x,answer1);
    	printf("log10(%lf)=%lf\n",y,answer2);
    	return 0;
    }

     

    sqrt(x)  求平方根   

    函数都在math.h 里编译时加上-lm    c++编译则不用

     

    4.rand()随机数函数

    先设置随机数种子 否则每次产生的随机数一样
    srand(time(0));

    头文件 #include<stdlib.h>

    int rand(void); //0~2147483674(0~RAND_MAX) 之间的随机数

    模板1:
    rand()/(RAND_MAX+1.0)                 产生:[0,1)
    int(10.0×rand()/(RAND_MAX+1.0))     产生[0,10)
    1+int(10.0×rand()/(RAND_MAX+1.0))     产生[1,10]

    模板2:
    rand()%(N+1)    产生[0,N]
    M+rand()%(N+1)  产生[M,M+N]

     

    4.1.产生10个1到10的随机数

    #include<stdio.h>
    #include "stdlib.h"
    int main(){
    	int i,j;
    	srand((int)time(0));
    	for(i=0;i<10;i++){
    		j=1+(int)(10.0*rand()/(RAND_MAX+1.0));
    		printf(" %d ",j);
    	}
    	printf("\n");
    	return 0;
    }

     

    4.2产生20个[100,1000]的随机数

    #include <stdlib.h>
    #include "stdio.h" 
    int main(){
    	int i,j; 
    	srand((int)time(0)); 
    	for(i=0;i<20;i++){
    		j=100+rand()%901;
    		printf(" %d ",j);
    		if(i==9) printf("\n");
    	}
    	printf("\n");
    }
    

     

    4.2字符函数的使用

    c语言字符函数
    函数名 功能
    isalnum 是否为英文字母或数字
    isalpha 是否为英文字母
    isascii 是否为ascii码字符
    isdigit 是否为阿拉伯数字
    islower 是否为小写英文字母
    isprint 是否为可打印字符
    isspace 是否为空格
    ispunct 是否为标点符号或特殊符号
    isupper 是否为大写英文字母
    isxdigit 是否为16进制数字
    头文件 #include<ctype.h>
    #include<stdio.h>
    #include <ctype.h>
    int main(){
    	char c;
    	while(scanf("%c",&c)==1){
    		if(isalnum(c)) printf("%c是英文字母或数字\n",c);
    		if(isalpha(c)) printf("%c是英文字母\n",c);
    		if(isascii(c)) printf("%c是ascii码字符\n",c);
    		if(iscntrl(c)) printf("%c是ascii码控制字符\n",c);
    		if(isdigit(c)) printf("%c是数字\n",c);
    		if(islower(c)) printf("%c是小写字母\n",c);
    		if(isupper(c)) printf("%c是大写字母\n",c);
    		if(isprint(c)) printf("%c是可打印字符\n",c);
    		if(isspace(c)) printf("%c是空格\n",c);
    		if(isxdigit(c)) printf("%c是16进制数字\n",c);
    		getchar();
    	}
    	return 0;
    }

     

     

    4.3系统时间与日期函数的使用

    系统时间

    系统时间与日期函数
    函数名 功能
    asctime 将时间和日期以字符串格式表示
    ctime 将时间和日期以字符串格式表示
    gettimeofday 取得当前时间
    gmtime 把时间和日期转换为格林尼治(GMT)时间(世界时)
    localtime 取得目前当地的时间和日期,并转换为现在的时间日期表示方法
    mktime 将时间结构数据转换成经过的秒数
    settimeofday 设置当前时间
    time 取得系统当前的时间
    //系统结构体
    struct tm{
    	int tm_sec;  //秒
    	int tm_min;  //分
    	int tm_hour; //时
    	int tm_mday;  //当前月日数
    	int tm_mon;  //月 0~11
    	int tm_year;  //1900至今的年数  1900+p->tm_year得到今年年份
    	int tm_wday;  //一星期的日数 0~6
    	int tm_yday;  //一年内的天数 0~365
    	int tm_isdst;  //夏时制时间	
    };

    头文件#include<time.h>
    time_t time(time_t *t);  
    取得当前时间 其实是返回1970年1月1日0:0:0至今的秒数 
    返回值会直接存到t指向的内存   

    头文件#include<time.h>
    struct tm* gmtime(const time_t* timep);
    将time_t里的秒数转换成现在的时间格式(格林尼治)  返回结构体struct_t

    头文件#include<time.h>
    char* asctime(const struct tm * timeptr);
    将结构体struct_tm里的时间转换成现在使用的时间日期表示法,格式为”Wed Jun 30 16:13:00 2018\n”

    头文件#include<time.h>
    struct tm *localtime(const time_t *timep);
    将time_t里的时间信息转换成现在使用的时间日期表示法,返回强悍的struct tm结构体

    eg1:time取得当前时间,gmtime转换成格林尼治时间,字符串形式输出(直接asctime函数转)。
             自己转换,成“xxxx年 x月 xx日 Tue 15:52:00"形式显示系统时间
     

    #include<time.h>
    int main(){
    	time_t timep;//时间结构体变量
    	char *wday[]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"}; 
    	struct tm *p;
    	time(&timep);//获取当前时间
    	printf("%s",asctime(gmtime(&timep)));
    	p=localtime(&timep);//获取当地时间 并按现在的时间日期来表示
    	printf("%d年 %d月 %d日\n",(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;
    }

    eg2:c语言写钟表

    #include<stdio.h>
    #include<time.h>
    #include <unistd.h>
    main(){
    	time_t timep;//时间结构体变量
    	struct tm *p;
    	while(1){
    		time(&timep);//获取当前时间
    		p=localtime(&timep);//获取当地时间 并按现在的时间日期来表示
    		printf("%d年%d月%d日 %d:%d:%02d\n",1900+p->tm_year,p->tm_mon+1,p->tm_mday,p->tm_hour,p->tm_min,p->tm_sec);
    		sleep(1);
    	}
     	printf("\n时间到!\n\a"); // \a是让系统发出声音的一种表达方式
     }

     

    时间间隔

    struct timeval{
           long tv_sec; //秒
           long tv_usec;//微秒
    };

    struct timezone{
           int tz_minuteswest; //和格林尼治时间差了多少分钟
           int tz_dsttime; //日光节约时间的状态
    };

    gettimeofday函数说明
    头文件:#include<sys/time.h>     #include<unistd.h>
    int gettimeofday(struct timeval * tv,struct timezone * tz)
    把当前时间分s与us放到tv中返回  当地时区信息放到tz中返回

    做某事的时间模板
    gettimeofday(&tv1,&tz);
    /*do something*/
    gettimeofday(&tv2,&tz);
    t=tv2.tv_sec-tv1.tv_sec+(tv2.tv_usec-tv1.tv_usec)*pow(10,-6);//s+us*10^-6

    eg1.

    #include <stdio.h>
    #include <unistd.h>
    #include <sys/time.h>
    int main(){
    	struct timeval tv1,tv2;
    	struct timezone tz;
    	gettimeofday(&tv1,&tz);
    	printf("1970距离今天tv_sec= %d 秒\n",tv1.tv_sec);
    	printf("零头有tv_usec= %d 微秒\n",tv1.tv_usec);
    	gettimeofday(&tv2,&tz);
    	printf("第7行到第10行程序耗时tv2_usec-tv1_usec= %d 微秒\n",tv2.tv_usec-tv1.tv_usec);//程序一定在ms内完成
    	//printf("%d\n",tv2.tv_sec-tv1.tv_sec);//绝对在ms级别 所以输出0
    	return 0;
    }

     

    exp2:大例

    #include<stdio.h>
    #include<stdlib.h>
    #include<sys/time.h>
    #include<unistd.h>
    int main()
    {
    	long int begin,sec,stop;
    	struct timeval tv1, tv2;
    	struct timezone tz;
    	char tmp;
    	begin=0;
    	stop=0;
    	sec=0;
    	system("clear");
    	printf("计时器程序(单位s)\n");
    	printf("输入b(begin)计时器开始计时\n");
    	printf("输入w(watch)查看已经累计时间\n");
    	printf("输入r(rest)重新开始计时\n");
    	printf("输入s(stop)暂停计时器\n");
    	printf("输入e(end)结束计时器\n");
    	while(1)
    	{
    		scanf("%c",&tmp);
    		if(tmp=='b')
    		{
    			if(begin==1&&stop==0)
    				printf("计时器已经启动!\n");
    			if(begin==0&&stop==0)
    			{
    				printf("计时器启动\n");
    				gettimeofday(&tv1,&tz);
    				sec=0;
    				begin=1;
    			}
    			if(stop==1)
    			{
    				gettimeofday(&tv1,&tz);
    				stop=0;
    				printf("暂停结束!\n");
    			}
    		}
    		if(tmp=='w'){
    			if(stop==0){
    				gettimeofday(&tv2,&tz);
    				printf("已经计时%ld 秒\n",sec+tv2.tv_sec-tv1.tv_sec);
    			}
    			if(stop==1)
    				printf("已经计时%ld 秒\n",sec);
    		}
    		if(tmp=='s'){
    			if(stop==1){
    				printf("计时已经暂停!\n");
    			}
    			if(stop==0){
    				gettimeofday(&tv2,&tz);
    				sec=sec+tv2.tv_sec-tv1.tv_sec;
    				printf("计时暂停,已经计时%ld 秒\n",sec);
    				stop=1;
    			}
    		}
    		if(tmp=='r'){
    			gettimeofday(&tv2,&tz); 
    			printf("已经计时%ld 秒\n",sec+tv2.tv_sec-tv1.tv_sec);
    			printf("计时器在5 秒后被重置!\n");
    			sleep(5);
    			begin=0;
    			sec=0;
    			stop=0;
    			system("clear");
    			printf("计时器程序(单位s)\n");
    			printf("输入b(begin)计时器开始计时\n");
    			printf("输入w(watch)查看已经累计时间\n");
    			printf("输入r(rest)重新开始计时\n");
    			printf("输入s(stop)暂停计时器\n");
    			printf("输入e(end)结束计时器\n");
    		}
    		if(tmp=='e') break;
    	}
    	return 0;
    }
    

     

     

    4.4环境控制函数

    常用环境控制函数
    函数名 功能
    getenv 取得环境变量的内容
    putenv/setenv 改变/增加环境变量
    unsetenv 取消已经改变的环境变量

    getenv函数:
    头文件:#include<stdlib.h>
    char* getenv(const char *name);  //失败返回null
    根据环境变量名name,取得该系统环境变量的值      环境变量格式key=value    

    eg1.获取当前登录用户

    当前登录用户环境变量key为USER  (只能大写,不能小写)

    #include<stdio.h>
    #include<stdlib.h>
    int main(){
    	char *p;
    	if((p=getenv("USER")))
    		printf("USER=%s\n", p);
    	return 0;
    }

     

    setenv函数:
    头文件:#include<stdlib.h>
    int setenv(const char *key,const char *value,int overwrite);
    改变或者增加环境变量     overwrite:1:改为value新值       0:该环境变量已有内容时,参数value被忽略(也即本次不改值)    

     

    eg2:修改USER的值

    #include<stdio.h>
    #include<stdlib.h>
    int main(){
    	char *p;
    	if(p=(getenv("USER"))){
    		printf("USER =%s\n",p);
    	}
    	setenv("USER","test",1);
    	printf("USER=%s\n",getenv("USER"));
    	unsetenv("USER");
    	printf("USER=%s\n",getenv("USER"));
    	setenv("USER","test",0);//USER无value时也会改
    	printf("USER=%s\n",getenv("USER"));
    	setenv("USER","test2",0);//USER有value时不会改 忽略test2 下面仍然输出test
    	printf("USER=%s\n",getenv("USER"));
    	return 1;	
    }

     

     

    exp3:输出系统所有的环境变量

    linuxC有一个全局变量 environ 在unistd.h里

    #include<stdio.h>
    int main(){
    	extern char **environ;//environ不能取别的名字 是系统全局变量
    	int i;
    	for(i=0;environ[i]!=NULL;i++){
    		printf("%s\n",environ[i]);
    	}
    	return 0;
    }

    或者不用extern声明 直接#include<unistd.h>

    #include<stdio.h>
    #include<unistd.h>
    int main(){
    	int i;
    	for(i=0;environ[i]!=NULL;i++){
    		printf("%s\n",environ[i]);
    	}
    	return 0;
    }

     

    4.5内存分配函数

    常用内存分配函数
    函数名 功能
    calloc/malloc 配置内存空间
    getpagesize 取得操作系统中内存分页大小
    mmap 建立内存映射
    munmap 解除内存映射
    free 释放原先配置的内存

    calloc函数
    头文件#include<stdlib.h>
    void *calloc(size_t nmemb,size_t size); //成功返回指针,失败返回NULL
    用来分配nmemb*size的内存块。
    nmemb为内存块的大小
    size为内存块的数量
    calloc()配置内存时会将内存内容初始化为0

    getpagesize函数
    头文件:#include<unistd.h>
    size_t getpagesize(void);
    取得内存分页大小
    取得的为系统分页大小,不一定和硬件分页大小相同

    malloc函数
    头文件:#include<stdlib.h>
    void *malloc(size_t size);//成功返回指针 失败返回NULL
    配置内存空间,大小由指定的size决定

    exp1.录入结构体

    #include<stdio.h>
    #include<stdlib.h>
    #include<unistd.h>
    #include<ctype.h>
    struct co
    {
    	int index;
    	char name[8];
    	char MTel[12];
    	char Tel[12];
    };
    int x;
    int main(){
    	freopen("input.txt","r",stdin);
    	struct co *p;
    	char ch;
    	printf("do you want to add a user?Y/N\n");
    	ch=getchar();
    	if(ch=='y'||ch=='Y'){
    		p=(struct co *)malloc(sizeof(struct co));
    		p->index=++x;
    		printf("User name:");
    		scanf("%s", p->name);
    		printf("MoveTel:");
    		scanf("%s",p->MTel);
    		printf("Tel:");
    		scanf("%s",p->Tel);
    		printf("intex:%d\nname:%s\nMoveTel:%s\nHomeTel:%s\n",p->index,p->name,p->MTel,p->Tel);
    	}
    	printf("page size=%d\n", getpagesize());/*取得内存分页大小*/
    	return 0;
    }

    input.txt:

    Y
    tomcat
    17812345678
    110

     

    mmap函数
    头文件:#include<unistd.h>   #inlucde<sys/mman.h>
    void *mmap(void *start,size_t length,int prot, int flags,int fd,off_t offsize);
    参数start指向对应的内存起始地址,通常设置为NULL

    参数length代表将文件中多大的部分对应到内存

    参数prot:映射区域的保护方式。可以为以下几种方式的组合:
    PROT_EXEC 映射区域可被执行
    PROT_READ 映射区域可被读取
    PROT_WRITE 映射区域可被写入
    PROT_NONE 映射区域不能存取

    参数flags:影响映射区域的各种特性。在调用mmap()时必须要指定MAP_SHARED 或MAP_PRIVATE。
    MAP_FIXED 如果参数start所指的地址无法成功建立映射时,则放弃映射,不对地址做修正。通常不鼓励用此旗标。
    MAP_SHARED对映射区域的写入数据会复制回文件内,而且允许其他映射该文件的进程共享。
    MAP_PRIVATE 对映射区域的写入操作会产生一个映射文件的复制,即私人的“写入时复制”(copy on write)对此区域作的任何修改都不会写回原来的文件内容。
    MAP_ANONYMOUS建立匿名映射。此时会忽略参数fd,不涉及文件,而且映射区域无法和其他进程共享。
    MAP_DENYWRITE只允许对映射区域的写入操作,其他对文件直接写入的操作将会被拒绝。
    MAP_LOCKED 将映射区域锁定住,这表示该区域不会被置换(swap)。

    参数fd:要映射到内存中的文件描述符。如果使用匿名内存映射时,即flags中设置了MAP_ANONYMOUS,fd设为-1。有些系统不支持匿名内存映射,则可以使用fopen打开/dev/zero文件,然后对该文件进行映射,可以同样达到匿名内存映射的效果。

    参数offset:文件映射的偏移量,通常设置为0,代表从文件最前方开始对应,offset必须是分页大小的整数倍。

    返回值:
    若映射成功则返回映射区的内存起始地址,否则返回MAP_FAILED(-1),错误原因存于errno 中。

     

    exp2:mmap读取文件内容

    #include<stdio.h>
    #include<sys/types.h>
    #include<sys/stat.h>
    #include<fcntl.h>
    #include<unistd.h>
    #include<sys/mman.h>
    int main(){
    	int fd;
    	void *start;
    	struct stat sb;
    	fd=open("/etc/passwd",O_RDONLY);//许多函数具体见第5章IO
    	fstat(fd,&sb);/*取得文件大小*/
    	start=mmap(NULL,sb.st_size,PROT_READ,MAP_PRIVATE,fd,0);/*文件映射到内存,始址为0,偏移量为0(从文件头开始)*/
    	if(start==MAP_FAILED) return 0;/*映射失败 直接返回*/
    	printf(" %s ", start);
    	munmap(start,sb.st_size);/*解除映射*/
    	close(fd);
    	return 0;
    }

     

    exp3:获取文件属性

    #include <stdio.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <unistd.h>
    int main()
    {
        const char fname[] = "main.c";
        struct stat stat_info;
        if(0 != stat(fname, &stat_info))
        {  
            perror("取得文件信息失败了!");
            exit(1);
        }
        printf("文件所在设备编号:%ld\r\n", stat_info.st_dev);
        printf("文件所在文件系统索引:%ld\r\n", stat_info.st_ino);
        printf("文件的类型和存取的权限:%d\r\n", stat_info.st_mode);
        printf("连到该文件的硬连接数目:%d\r\n", stat_info.st_nlink);
        printf("文件所有者的用户识别码:%d\r\n", stat_info.st_uid);
        printf("文件所有者的组识别码:%d\r\n", stat_info.st_gid);
        printf("装置设备文件:%ld\r\n", stat_info.st_rdev);
        printf("文件大小:%ld\r\n", stat_info.st_size);
        printf("文件系统的I/O缓冲区大小:%ld\r\n", stat_info.st_blksize);
        printf("占用文件区块的个数(每一区块大小为512个字节):%ld\r\n", stat_info.st_blocks);
        printf("文件最近一次被存取或被执行的时间:%ld\r\n", stat_info.st_atime);
        printf("文件最后一次被修改的时间:%ld\r\n", stat_info.st_mtime);
        printf("最近一次被更改的时间:%ld\r\n", stat_info.st_ctime);
        return 0;
    }

    mian.c在当前目录下

     

    4.6数据结构中常用函数

    函数名 功能
    bsearch 二分法搜索
    lfind/lsearch 线性搜索,lsearch()找不到关键数据时会主动把改项数据加入数组里
    qsort 利用快速排序法排序数组

    qsort()函数:
    头文件:#include<stdlib.h>
    void qsort(void* base,size_t n,size_t size,
                int(*compar)(const void*,const void*));
    eg:qsort(base,n,sizeof(int),compar); //对数组base[n]排序
    利用快速排序法排列数组
    base指向要被搜索的数组的开头地址
    n代表数组中元素数量
    size为每一元素大小
    compar为函数指针,数据相同时则返回0;不同时返回非0值。返回1时两个数据交换,返回-1时两个数据不交换.不可缺省

     

    exp1:输入n,再输入n个整数,qsort()对n个整数进行排序

    #include<stdio.h>
    #include<stdlib.h>
    #define m 70
    int compar (const void *a,const void *b){
    	int *pa=(int *)a,*pb=(int*)b;
    	if(*pa>*pb) return 1;
    	if(*pa == *pb) return 0;
    	if(*pa < *pb) return -1;
    }
    int main(){
    	freopen("input.txt","r",stdin);
    	int base[m],n;
    	int i;
    	printf("input n(n<50):");
    	scanf("%d",&n);
    	for (int i = 0; i < n; ++i)	{
    		scanf("%d",&base[i]);
    	}
    	printf("\n排序前:\n");
    	for (int i = 0; i < n; ++i)	{
    		printf("%d ",base[i]);
    		if(i!=0&&i%10==0) printf("\n");
    	}
    	qsort(base,n,sizeof(int),compar);//必须有compar 没有会报错 无默认比较函数
    	printf("\n排序后:\n");
    	for (int i = 0; i < n; ++i)	{
    		printf("%d ",base[i]);
    		if(i!=0&&i%10==0) printf("\n");
    	}
    	printf("\n");
    	return 0;
    }

    input.txt

    10
    6 7 -9 89 72 -89 0 10 7890 -909887

     

    字符串查找

    lfind函数:
    头文件:#include<stdlib.h>
    void *lfind(const void *key,const void *base,size_t *n,size_t size,int(* compar)(const void*,const void*));
    函数功能:线性搜索,在数组中从头至尾,一项项查找数据
    eg:lsearch(key,base,&n,size,compar);//char[] key;char[] base;int n;int size;
    key:指向欲查找的关键数据的指针
    base:指向要被搜索的数组开头的地址
    n:数组中元素的数量
    size:每一个元素的大小
    compar:函数指针,相同返回0,不同返回非0
    lfind和lsearch的不同点在于,当找不到关键数据时lfind()仅仅会返回NULL,而不会主动把该数据加入数组尾端。如果lsearch()找不到关键数据,会主动把该数据加入数组里。

    bsearch函数说明:
    void *bsearch(const void* key,const void *base,size_t n,size_t size,int(*compar)(const void*,const void*));
    利用二分搜索法从排序好的数组中查找数据
    key:指向欲查找的关键数据的指针
    base:指向要被搜索的数组开头地址
    n:数组中元素数量
    size:每一元素的大小
    compar:函数指针,数据相同时返回0,不同时返回

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

    展开全文
  • 因为需要将日志文件发送到ftp中保存,但是同一个日志文件可能存了2-3天的内容,为减少后期“因为每天存一个日志,而内容有重复”这一工作量,在发送到ftp时,检测其“修改时间差”来命名文件。 ...

     

    因为需要将日志文件发送到ftp中保存,但是同一个日志文件可能存了2-3天的内容,为减少后期“因为每天存一个日志,而内容有重复”这一工作量,在发送到ftp时,检测其“修改时间差”来命名文件。

    1. 脚本语句中if判断内不支持ftp的打开/关闭,所以不能用if+“修改时间差”来判断是否打开ftp保存文件。

    2.所以,依旧是每天保存一份,只是如果文件没修改,则保存为上一次(即修改当日的)文件名,这样不产生多个文件名不同但内容相同的文件。

    3. 曲线完成需求。

    currentDate=`date +%s`
    modifyDate=$(stat -c %Y "/iiidb/errlog/bibtemp.log.0")
    logExistTime=$(($currentDate - $modifyDate))
    logExistTime=$(($logExistTime/86400))
    
    
    put /iiidb/errlog/bibtemp.log.0 bib/bibtemp-$(date -d -${logExistTime}day '+%Y%m%d').log.0
    

     

     

    日志修改时间戳参考:

    https://www.cnblogs.com/KevinSong/p/3816981.html

    #!/bin/bash
    
    log_path=""         #此处定义你的日志文件夹路径
    expried_time=7      #此处定义你的日志过期时间,如7天
    
    function deleteLogs(){
        # 获取系统时间,所有时间格式都是秒
        local currentDate=`date +%s`
        echo "current date: " $currentDate
    
        for file in `find $1 -name "*.js_*.log"` #此处定义文件名格式,避免误删
        do
            local name=$file
            local modifyDate=$(stat -c %Y $file)
    
            #对比时间,算出日志存在时间,距离最近一次修改
            local logExistTime=$(($currentDate - $modifyDate))
            logExistTime=$(($logExistTime/86400))
            
            if [ $logExistTime -gt $expried_time ]; then
                echo "File: " $name "Modify Date: " $modifyDate + "Exist Time: " $logExistTime + "Delete: yes"
                rm -f $file
            else
                echo "File: " $name "Modify Date: " $modifyDate + "Exist Time: " $logExistTime + "Delete: no"
            fi
        done
    }
    
    deleteLogs $log_path

     

    http://www.cnblogs.com/huixuexidezhu/p/9573194.html

    Linux中日期的加减运算

     

    目录

     

    正文

    • date命令本身提供了日期的加减运算。
    • date 可以用来显示或设定系统的日期与时间。

    回到顶部

    在显示方面

    使用者可以设定欲显示的格式,格式设定为一个加号后接数个标记,其中可用的标记列表如下: % :  打印出 %
    %n : 下一行
    %t : 跳格
    %H : 小时(00..23)
    %I : 小时(01..12)
    %k : 小时(0..23)
    %l : 小时(1..12)
    %M : 分钟(00..59)
    %p : 显示本地 AM 或 PM
    %r : 直接显示时间 (12 小时制,格式为 hh:mm:ss [AP]M)
    %s : 从 1970 年 1 月 1 日 00:00:00 UTC 到目前为止的秒数
    %S : 秒(00..61)
    %T : 直接显示时间 (24 小时制)
    %X : 相当于 %H:%M:%S
    %Z : 显示时区 %a : 星期几 (Sun..Sat)
    %A : 星期几 (Sunday..Saturday)
    %b : 月份 (Jan..Dec)
    %B : 月份 (January..December)
    %c : 直接显示日期与时间
    %d : 日 (01..31)
    %D : 直接显示日期 (mm/dd/yy)
    %h : 同 %b
    %j : 一年中的第几天 (001..366)
    %m : 月份 (01..12)
    %U : 一年中的第几周 (00..53) (以 Sunday 为一周的第一天的情形)
    %w : 一周中的第几天 (0..6)
    %W : 一年中的第几周 (00..53) (以 Monday 为一周的第一天的情形)
    %x : 直接显示日期 (mm/dd/yy)
    %y : 年份的最后两位数字 (00.99)
    %Y : 完整年份 (0000..9999)

    回到顶部

    在设定时间方面

    date -s //设置当前时间,只有root权限才能设置,其他只能查看。
    date -s 20080523 //设置成20080523,这样会把具体时间设置成空00:00:00
    date -s 01:01:01 //设置具体时间,不会对日期做更改
    date -s “01:01:01 2008-05-23″ //这样可以设置全部时间
    date -s “01:01:01 20080523″ //这样可以设置全部时间
    date -s “2008-05-23 01:01:01″ //这样可以设置全部时间
    date -s “20080523 01:01:01″ //这样可以设置全部时间

    回到顶部

    时间的加减

    date +%Y%m%d         //显示现在天年月日
    date +%Y%m%d --date="+1 day"  //显示后一天的日期
    date +%Y%m%d --date="-1 day"  //显示前一天的日期
    date +%Y%m%d --date="-1 month"  //显示上一月的日期
    date +%Y%m%d --date="+1 month"  //显示下一月的日期
    date +%Y%m%d --date="-1 year"  //显示前一年的日期
    date +%Y%m%d --date="+1 year"  //显示下一年的日期

    date=`date -d -${t}day '+%Y%m%d'` //为t为前几天

    展开全文
  • Linux-0.11 kernel_mktime函数分析

    千次阅读 2014-12-09 19:58:46
    kernel_mktime函数在kernel/mktime.c文件中,代码如下:/* * linux/kernel/mktime.c * * (C) 1991 Linus Torvalds */ #include /* * This isn't the library routine, it is only used in the kernel. * as...
  • 函数功能介绍 使用man gmtime或man localtime都可以的得到这几个函数的介绍。原型如下: struct tm *gmtime(const time_t *timep); struct tm *gmtime_r(const time_t *timep, struct tm *result); struct tm *...
  • 1. 编写一个函数,输入年份,判断是否为闰年; 2. 编写一个函数,输入年份,判断当年元旦所对应的星期数; 3. 输入日期(年、月、日),输出他是该年的第几天、星期几。 4. 调用【实验一】中1、2的两个函数,打印...
  • 题目要求:2007年1月1日为星期一,编写一个函数,输出2007年任意月份的日历 这道题我是个人的做法,有个别地方可能有些绕。 #include&amp;amp;amp;lt;stdio.h&amp;amp;amp;gt; int main() { int month,...
  • Linux源码中的mktime算法解析  我们知道,从CMOS中读出来的系统时间并不是time_t类型,而是类似于struct tm那样,年月日时分秒是分开存储的。  那么,要把它转化为系统便于处理的time_t类型,就需要算法进行转换...
  • Linux时间函数札记

    2017-04-27 11:23:39
    关于gmtime、gmtime_r、localtime、localtime_r 测试环境:vmware 7 + Redhat5.5,... 使用man gmtime或man localtime都可以的得到这几个函数的介绍。原型如下:  struct tm *gmtime(const ti
  • 原文链接:http://blog.csdn.net/axx1611/article/details/1792827
  • linux时间类型localtime_r

    千次阅读 2018-09-21 10:00:37
    linux时间类型localtime_r,struct tm *p gettimeofday(&amp;now ,NULL);取得当前时间的参数值,now可以是struct timespec 或者 struct timeval 类型的。  mktime函数原型: 定义函数   time_t ...
  • EXCEL函数大全

    千次阅读 2018-12-15 10:01:49
    函数 用途 语法 参数 1 一.数据库函数       2 1.DAVERAGE 用途:返回数据库或数据清单中满足指定条件的列中数值的平均值。 语法:DAVERAGE(database,field,criteria) ...
  • #include <stdio.h> int getWeekdayByYearday(int iY, int iM, int iD) { int iWeekDay = -1; if (1 == iM || 2 == iM) { iM += 12;... iWeekDay = (iD + 1 + 2 * iM + 3 * (iM + 1) / 5 + iY + iY / 4 - ...
  • 注意特殊月份二月,设置月份数组,设置判断闰年判断函数,闰年改变二月份数组值,平年数组不变,计算出这一天是这一年的第几天,然后求差值。 年份不同; 相差一年。先判断每一年的闰年平年情况,值a:前一年...
  • 文章目录1、linux中date函数格式2、date日期函数的具体用法2.1、获取相应格式的日期2.2、获取相隔时间段的日期2.2.1、获取今天的日期2.2.2、获取昨天的日期2.2.3、获取明天的日期2.3、获取当前时间戳2.3、将指定时间...
  • 1、函数功能介绍 使用man gmtime或man localtime都可以的得到这几个函数的介绍。原型如下: struct tm *gmtime(const time_t *timep); struct tm *gmtime_r(const time_t *timep, struct...
  • Linux基础(一)

    千次阅读 2020-02-29 20:25:39
    1. Linux多个发行版间的联系与区别 1.1 什么是LinuxLinux是一套免费使用和自由传播的类Unix操作系统,是一个基于POSIX和UNIX的多用户,多任务,支持多线程和多CPU的操作系统。它能运行主要的Unix工具软件,应用...
  • package com.gcloud.common;import org.apache.http.util.TextUtils...import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; import java.util.re
  • 1. 判断年份是否为闰年 ...如果某年份能被4整除但不能被100整除,那么这一年为闰年;或者能被400整除也是闰年。 /************************************************************************* > File Name: le...
1 2 3 4 5 ... 20
收藏数 1,482
精华内容 592
关键字:

linux 年份函数加一年