我想了解time()和gmtime()的用法意思，真的不会T T望指教！【localtime】time() 获取当前时间值（整数），表示1970.1.1以来的秒数 。
The time function returns the number of seconds
elapsed since midnight (00:00:00), January 1, 1970, Coordinated Universal Time
(UTC), according to the system clock.

gmtime 把整数时间值转换成结构体，以便取出年，月，日 等详情 。

Convert a time value to a structure，

Linux中gmtime和localtime的区别格林威治时间，也就是格林威治天文台的时间，这个是世界标准时 。本初子午线就是画在了格林威治天文台所在的经度上 。

这个时间不管你在什么地方 ， 都是一样的 。因为格林威治天文台是不会乱窜的 。

localtime 是本地时间 。这个本地时间，就是看这个地方所在的时区 。
时间是午夜为 00 点 00 分 。所以格林威治时间，就是格林威治午夜定为 00 点 00 分 。

但是因为地球是圆的，别的地方如果使用格林威治的午夜定位 00 点 00 分 ， 就会出现太阳在不同位置的问题 。比如格林威治午夜 00：00 ，新西兰正值中午
所以地球上划分了 24 个时区，每个时区相差一个小时（国际日期变更线两边相差 24 小时） 。各个地方都把自己所在时区当作本地时间.当然并不一定非要按照自己在什么地方就用什么时间，比如中国就是同一 +8 GMT （也就是格林威治时间 +8 小时），新疆就算不在 +8 GMT 这个区域上也用北京一样的时间 ， 便于时间统一 。

这就是两个的区别 。

用localtime和gmtime得到的不同值，用mktime所得到的秒数是一样的Linux中gmtime和localtime的区别 前段时间用到，写了段小测试代码，个人觉得足够清楚的表明了二者的区别了，还是不明白的话，就看看APUE里面的章节吧 。#include #include int main(int argc, char **argv) { time_t tmpcal_ptr = {0};

C++ 如何将世界时间转化成北京时间？（用localtime函数是如何区分大月还是小月还有平月？为方便调试程序，输入数据我用了空格 。

#include
#include
void main(){
struct tm *ptm;
time_trawtime, t;
int year,month,mday,hh,mm,ss;



time ( &rawtime );
ptm = gmtime ( &rawtime );//建 UTC 时间

printf("Please enter year month day hour minute second\n");
printf("For example: \n");
printf("2013 2 28 23 35 4\n");
scanf("%d %d %d %d %d %d", &year, &month, &mday, &hh,&mm,&ss);
ptm->tm_year = year - 1900;
ptm->tm_mon= month - 1;
ptm->tm_mday = mday ;
ptm->tm_hour = hh ;
ptm->tm_min = mm ;
ptm->tm_sec = ss ;
t = mktime (ptm);//得 UTC 时间 年月日时分秒
printf("%s ",ctime(&t));// 打印出 Thu Feb 28 23:35:04 2013
t = t+8*3600;//北京时间，加 8 小时就是
printf("%s ",ctime(&t));// 打印出 Fri Mar 01 07:35:04 2013
}

// MS VC++ 6.0 编译器

c语言 时间函数c语言时间函数：
1、获得日历时间函数：
可以通过time()函数来获得日历时间（Calendar Time），其原型为：time_t time(time_t * timer);
如果已经声明了参数timer，可以从参数timer返回现在的日历时间，同时也可以通过返回值返回现在的日历时间，即从一个时间点（例如：1970年1月1日0时0分0秒）到现在此时的秒数 。如果参数为空（NUL），函数将只通过返回值返回现在的日历时间，比如下面这个例子用来显示当前的日历时间：
2、获得日期和时间函数：
这里说的日期和时间就是平时所说的年、月、日、时、分、秒等信息 。从第2节我们已经知道这些信息都保存在一个名为tm的结构体中，那么如何将一个日历时间保存为一个tm结构的对象呢？
其中可以使用的函数是gmtime()和localtime()，这两个函数的原型为：
struct tm * gmtime(const time_t *timer);
struct tm * localtime(const time_t * timer);
其中gmtime()函数是将日历时间转化为世界标准时间（即格林尼治时间），并返回一个tm结构体来保存这个时间 ， 而localtime()函数是将日历时间转化为本地时间 。比如现在用gmtime()函数获得的世界标准时间是2005年7月30日7点18分20秒，那么用localtime()函数在中国地区获得的本地时间会比世界标准时间晚8个小时，即2005年7月30日15点18分20秒 。

求"RIGHT-right",local=localtime(case37:elseif(c!=0)printf("thereare因为templatecursor(x,y);

谁能解释下关于 c++ localtime()一顺来就可以了,
首先声明了一个结构体,类型是struct tm *名字是local,
之后声明了一个time_t的数据类型,名字是t,
然后调用time()函数,time函数的返回值是time_t类型的,于是赋值给t,
接着调用localtime()函数,函数需要传递进去的参数是&t,也就是之前t的地址,localtime()的返回值是一个struct tm结构,于是返回值用local保存.
printf就是格式化输出字符串,这个真没啥好说的,哪个学编程的第一句不是输出helloworld的.
local->tm_hour,就是访问local结构的tm_hour.配合printf也就是输出tm_hour的值了.

如果对localtime()函数有不了解的地方,去MSDN或者直接谷歌一下就可以了.有很多资料的.

localtime在C中的用法time_t t = time(0);
char tmp[64];
strftime(tmp, sizeof(tmp), "System-%Y-%m.log", localtime(&t) );
struct tm* ptmTemp = localtime(&t);
int nyear = ptmTemp->tm_year;

localtime在易语言怎么使用.版本 2

.局部变量 时间, 日期时间型
时间 ＝ 取现行时间 ()

''要取这个时间的年月日,时分秒,可以

.版本 2

取年份 (时间)
取月份 (时间)
取日 (时间)
取小时 (时间)
取分钟 (时间)
取秒 (时间)

localtime(&timep)是如何实现的?调试到localtime里面去看源码、

python中的time模块，如何获取当前时间并格import time# 使用time获取当前时间time.localtime()# 使用 time 模块的 strftime 方法来格式化日期，：# 格式化成2018-05-28 17:36:35形式print (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) )# 格式化成Mon May 28 17:36:35 2018形式print (time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()))python3
python time模块通过time.strftime获取时间格式中的月份是带有0的import datetimed = datetime.date(2019, 2, 14)print('%d-%d-%d' % (d.year, d.month, d.day))

python中引用time模块，其中有一条语句有点疑问，求大神指点，time·local+（）python3.4.2，time模块没有time·local+（）这个函数，但是我猜你是问的对返回值后面加中括号的作用，这个作用是表示对可迭代对象如数组、元祖、字符串等对象的引用 ， 括号中的数字表示对对象中第n-1个元素的引用（下标从0开始 ， 所以要减1）

python 的time模块获取的是什么时间好像是秒，可以用datetime模块中的datetime函数转换成一般的时间格式

python中哪个模块可以输出今天的日期import time
print time.time()
输出的结果是：
1279578704.6725271
但是这样是一连串的数字不是我们想要的结果 ， 我们可以利用time模块的格式化时间的方法来处理：
time.localtime(time.time())
用time.localtime()方法，作用是格式化时间戳为本地的时间 。
输出的结果是：
time.struct_time(tm_year=2010, tm_mon=7, tm_mday=19, tm_hour=22, tm_min=33, tm_sec=39, tm_wday=0, tm_yday=200, tm_isdst=0)
现在看起来更有希望格式成我们想要的时间了 。
time.strftime('%Y-%m-%d',time.localtime(time.time()))
最后用time.strftime()方法，把刚才的一大串信息格式化成我们想要的东西 ， 现在的结果是：
2010-07-19

C语言关于localtime_s()和asctime_s()两个函数的用法Visual C++ 6.0开发环境中显示当地日期与时间主要通过localtime()函数来实现，该函数的原型在time.h头文件中，其语法格式如下：struct tm *localtime(xonst time_t *timer)该函数的作用是把timer所指的时间（如函数time返回的时间）转换为当地标准时间，并以tm结构形式返回 。其中，参数timer为主要获取当前时间的传递参数，格式为time_t指针类型 。而在Visual Studio 2010极其以后的版本，新增了安全函数，改成localtime_s()，语法格式也发生了变化：errno_t localtime_s(struct tm* _tm,const time_t *time );其中：_tm指向要填充的时间结构的指针 。time指针，指向存储的时间 。如果成功，返回值则为零 。如果失败，返回值将是错误代码 。错误代码是在 Errno.h 中定义的 。结构类型的字段 tm 存储下面的值，其中每个为 int 。tm_sec分钟后的几秒 (0-59) 。tm_min小时后的分钟 (0-59) 。tm_hour午夜后经过的小时 (0-23) 。tm_mday月 (1-31) 天 。tm_mon月 (0 – 11;年 1 月 = 0） 。tm_year年份 （当前年份减去 1900年） 。tm_wday星期几 (0 – 6;星期日 = 0） 。tm_yday每年的一天 (0-365;1 月 1 日 = 0) 。tm_isdst如果夏令时有效，则为，正值夏时制不起作用; 如果为 0如果夏时制的状态是未知的负值 。如果 TZ 设置环境变量，C 运行库会假定规则适用于美国境内用于实现夏令时 (DST) 计算 。下面以一个Visual Studio 2015实例来输出当地日期与时间：#include #includeusing namespace std; int main(void){struct tm t;//tm结构指针time_t now;//声明time_t类型变量time(&now);//获取系统日期和时间localtime_s(&t, &now);//获取当地日期和时间//格式化输出本地时间printf("年：%d\n", t.tm_year + 1900);printf("月：%d\n", t.tm_mon + 1);printf("日：%d\n", t.tm_mday);printf("周：%d\n", t.tm_wday);printf("一年中的第%d天\n", t.tm_yday);printf("时：%d\n", t.tm_hour);printf("分：%d\n", t.tm_min);printf("秒：%d\n", t.tm_sec);printf("夏令时：%d\n", t.tm_isdst);system("pause");return 0;}

c语言中time函数的用法头文件time.h

@函数名称:localtime
函数原型:struct tm *localtime(const time_t *timer)
函数功能:返回一个以tm结构表达的机器时间信息
函数返回:以tm结构表达的时间，结构tm定义如下:
structtm{
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;
};
参数说明:timer-使用time()函数获得的机器时间

#include
#include
#include
int main()
{
time_t timer;
struct tm *tblock;
timer=time(NULL);
tblock=localtime(&timer);
printf("Local time is: %s",asctime(tblock));
return 0;
}


@函数名称:asctime
函数原型:char* asctime(struct tm * ptr)
函数功能:得到机器时间(日期时间转换为ASCII码)
函数返回:返回的时间字符串格式为：星期,月,日,小时：分：秒,年
参数说明:结构指针ptr应通过函数localtime()和gmtime()得到
所属文件:

#include
#include
#include
int main()
{
struct tm t;
char str[80];
t.tm_sec=1;
t.tm_min=3;
t.tm_hour=7;
t.tm_mday=22;
t.tm_mon=11;
t.tm_year=56;
t.tm_wday=4;
t.tm_yday=0;
t.tm_isdst=0;
strcpy(str,asctime(&t));
printf("%s",str);
return 0;
}


@函数名称:ctime
函数原型:char *ctime(long time)
函数功能:得到日历时间
函数返回:返回字符串格式：星期,月,日,小时:分:秒,年
参数说明:time-该参数应由函数time获得
所属文件:

#include
#include
int main()
{
time_t t;
time(&t);
printf("Today's date and time: %s",ctime(&t));
return 0;
}


@函数名称:difftime
函数原型:double difftime(time_t time2, time_t time1)
函数功能:得到两次机器时间差，单位为秒
函数返回:时间差 ， 单位为秒
参数说明:time1-机器时间一,time2-机器时间二.该参数应使用time函数获得
所属文件:

#include
#include
#include
#include
int main()
{
time_t first, second;
clrscr();
first=time(NULL);
delay(2000);
second=time(NULL);
printf("The difference is: %f seconds",difftime(second,first));
getch();
return 0;
}


@函数名称:gmtime
函数原型:struct tm *gmtime(time_t*time)
函数功能:得到以结构tm表示的时间信息
函数返回:以结构tm表示的时间信息指针
参数说明:time-用函数time()得到的时间信息
所属文件:

#include
#include
#include
#include
char *tzstr="TZ=PST8PDT";
int main()
{
time_t t;
struct tm *gmt, *area;
putenv(tzstr);
tzset();
t=time(NULL);
area=localtime(&t);
printf("Local time is:%s", asctime(area));
gmt=gmtime(&t);
printf("GMT is:%s", asctime(gmt));
return 0;
}


@函数名称:time
函数原型:time_t time(time_t *timer)
函数功能:得到机器的日历时间或者设置日历时间
函数返回:机器日历时间
参数说明:timer=NULL时得到机器日历时间 ， timer=时间数值时，用于设置日历时间，time_t是一个long类型
所属文件:

#include
#include
#include
int main()
{
time_t t;
t=time();
printf("The number of seconds since January 1,1970 is %ld",t);
return 0;
}


@函数名称:tzset
函数原型:void tzset(void)
函数功能:UNIX兼容函数，用于得到时区，在DOS环境下无用途
函数返回:
参数说明:
所属文件:

#include
#include
#include
int main()
{
time_t td;
putenv("TZ=PST8PDT");
tzset();
time(&td);
printf("Current time=%s",asctime(localtime(&td)));
return 0;
}

C语言的问题：请问ctime()和asctime有什么区别？asctime是把时间换成ascii码 。
ctime是把时间转换成字符串 。


具体介绍如下：



函数名: asctime
功 能: 转换日期和时间为ASCII码
用 法: char *asctime(const struct tm *tblock);
程序例:
#include
#include
#include
int main(void)
{
struct tm t;
char str[80];
/* sample loading of tm structure */
t.tm_sec = 1; /* Seconds */
t.tm_min = 30; /* Minutes */
t.tm_hour = 9; /* Hour */
t.tm_mday = 22; /* Day of the Month */
t.tm_mon = 11; /* Month */
t.tm_year = 56; /* Year - does not include century */
t.tm_wday = 4; /* Day of the week */
t.tm_yday = 0; /* Does not show in asctime */
t.tm_isdst = 0; /* Is Daylight SavTime; does not show in asctime */
/* converts structure to null terminated
string */
strcpy(str, asctime(&t));
printf("%s\n", str);
return 0;
}
英文详解：
[编辑本段]asctime


Synopsis
#include
char *asctime(const struct tm *timeptr);
Description
The asctime function converts the broken-down time in the structure pointed to by timeptr into a string in the form
Sun Sep 16 01:03:52 1973\n\0
using the equivalent of the following algorithm.
char *asctime(const struct tm *timeptr)
{
static const char wday_name[7][3] = {
"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
};
static const char mon_name[12][3] = {
"Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
};
static char result[26];
sprintf(result, "%.3s %.3s%3d %.2d:%.2d:%.2d %d\n",
wday_name[timeptr->tm_wday],
mon_name[timeptr->tm_mon],
timeptr->tm_mday, timeptr->tm_hour,
timeptr->tm_min, timeptr->tm_sec,
1900 + timeptr->tm_year);
return result;
}
Returns
The asctime function returns a pointer to the string.
Example :
#include
#include
void main(void)
{
struct tm *newtime;
time_t ltime;
/* Get the time in seconds */
time (<ime);
/* convert it to the structure tm */
newtime = localtime(<ime);
/* print the local time as a string */
printf("The current time and dat are %s", asctime(newtime));
}
The current time and dat are Mon Dec 28 12:33:50 1998




ctime
函数名: ctime
功 能: 把日期和时间转换为字符串
用 法: char *ctime(const time_t *time);
程序例:
#include
#include
int main(void)
{
time_t t;
time(&t);
printf("Today's date and time: %s\n", ctime(&t));
return 0;
}

c语言 localtime函数 问题#include
#include
main()
{
long i;
struct tm *tblock;
i=0;
i= time(NULL);
tblock=localtime(&i);
printf("\n%s",asctime(tblock));
}

VS2012编译器中 localtime 函数使用问题localtime在vs2010以后的版本都被认为是不安全的，使用localtime_s,

localTime = localtime(&curTime);这是微软SB的东西，把localtime函数改为函数localtime_s，然后参数参照localtime_s的参数修改即可 ， 只是增加了安全性

localtime（）这样用错了吗？time_t t_NowUnixTime=time(NULL);
struct tm NowDateTime ;
NowDateTime = *localtime(&t_NowUnixTime);
printf("%d\n",NowDateTime.tm_year+1900);
我这边没有问题，代码也符合逻辑，估计是不是t_NowUnixTime没有初始化，如果不初始化确实会在第三句话中断

vs2013写c++程序，其中localtime_s函数不接受一个参数怎么解决？！Visual C++ 6.0开发环境中显示当地日期与时间主要通过localtime()函数来实现 ， 该函数的原型在time.h头文件中，其语法格式如下：struct tm *localtime(xonst time_t *timer)该函数的作用是把timer所指的时间（如函数time返回的时间）转换为当地标准时间，并以tm结构形式返回 。其中 ， 参数timer为主要获取当前时间的传递参数，格式为time_t指针类型 。而在Visual Studio 2010及其以后的版本，新增了安全函数，改成localtime_s()，语法格式也发生了变化：errno_t localtime_s(struct tm* _tm,const time_t *time );其中：_tm指向要填充的时间结构的指针 。time指针，指向存储的时间 。如果成功 ， 返回值则为零 。如果失败，返回值将是错误代码 。错误代码是在 Errno.h 中定义的 。结构类型的字段 tm 存储下面的值，其中每个为 int 。tm_sec分钟后的几秒 (0-59) 。tm_min小时后的分钟 (0-59) 。tm_hour午夜后经过的小时 (0-23) 。tm_mday月 (1-31) 天 。tm_mon月 (0 – 11;年 1 月 = 0） 。tm_year年份 （当前年份减去 1900年） 。tm_wday星期几 (0 – 6;星期日 = 0） 。tm_yday每年的一天 (0-365;1 月 1 日 = 0) 。tm_isdst如果夏令时有效，则为，正值夏时制不起作用; 如果为 0如果夏时制的状态是未知的负值 。如果 TZ 设置环境变量，C 运行库会假定规则适用于美国境内用于实现夏令时 (DST) 计算 。下面以一个Visual Studio 2015实例来输出当地日期与时间：#include #include using namespace std;int main(void){struct tm t;//tm结构指针time_t now;//声明time_t类型变量time(&now);//获取系统日期和时间localtime_s(&t, &now);//获取当地日期和时间//格式化输出本地时间printf("年：%d\n", t.tm_year + 1900);printf("月：%d\n", t.tm_mon + 1);printf("日：%d\n", t.tm_mday);printf("周：%d\n", t.tm_wday);printf("一年中的第%d天\n", t.tm_yday);printf("时：%d\n", t.tm_hour);printf("分：%d\n", t.tm_min);printf("秒：%d\n", t.tm_sec);printf("夏令时：%d\n", t.tm_isdst);system("pause");return 0;}

tm tim=*localtime(&curtime);这个C++语句怎么解释？？最好详细点……把系统时间转换成本地时间, 以指针形式存入tim

C/C++中关于时间函数time()的应用问题time_t curTime;//定义time_t变量

struct tm * datePtr = NULL;//定义tm指针

char timeStr[40];//定义用于保存时间字符串的char数组
time(&curTime);//取当前时间，其值表示从1970年1月1日00:00:00到当前时刻的秒数
datePtr = localtime(&curTime);//把从1970-1-1零点零分到当前时间系统所偏移的秒数时间转换为日历时间


sprintf(timeStr,"%d/%d/%d___%d:%d:%d",(1900 + datePtr->tm_year),
(1 + datePtr->tm_mon),
datePtr->tm_mday,
datePtr->tm_hour,
datePtr->tm_min,
datePtr->tm_sec);//格式化字符串 类似：2013/4/10___10:51:56tm_year是年份，从1900开始所以要加1900，tm_mon是月份，用0开始 ， 所以要加1 。

Python 时间模块 time.localtime() 和 time.localtime(time.time()) 有什么区别看文档啊如果参数为空，就为当前时间 。
时间函数 gmtime 和 localtime 有什么区别1、localtime是把从1970-1-1零点零分到当前时间系统所偏移的秒数时间转换为本地时间，而gmtime函数转换后的时间没有经过时区变换，是UTC时间 。2、说明：此函数获得的tm结构体的时间是日历时间 。3、用法:structtm*localtime(consttime_t*clock);4、返回值：返回指向tm结构体的指针.tm结构体是time.h中定义的用于分别存储时间的各个量(年月日等)的结构体.5、范例

python time.clock 和time.time的区别一，两个函数的文档：

1，time.time():


time.time()

Return
the time in seconds since the epoch as a floating point number. Note
that even though the time is always returned as a floating point number,
not all systems provide time with a better precision than 1 second.
While this function normally returns non-decreasing values, it can
return a lower value than a previous call if the system clock has been
set back between the two calls.



time.time()

返回从纪元（1970.1.1）至今的秒数 。虽然这个函数的返回值永远为浮点数 ， 但并不是所有系统提供的秒数都会精确到小数点以后 。一般情况下这个函数的返回值不会小于它上一次被调用的返回值 ， 除非系统时钟在两次调用之间发生了重置 。


2，time.clock():



time.clock()

On
Unix, return the current processor time as a floating point number
expressed in seconds. The precision, and in fact the very definition of
the meaning of “processor time”, depends on that of the C function of
the same name, but in any case, this is the function to use for
benchmarking Python or timing algorithms.
On Windows, this
function returns wall-clock seconds elapsed since the first call to this
function, as a floating point number, based on the Win32 function QueryPerformanceCounter(). The resolution is typically better than one microsecond.





time.clock()


在Unix 中，将当前的处理器时间以浮点数的形式返回，单位为秒 。它的精确度（准确地说是“处理器时间”的精确度）取决于同名的C函数，无论如何，这个函数是python关于时间计算的标尺 。



WINDOWS中，第一次调用，返回的是进程运行的实际时间 。而第二次之后的调用是自第一次调用以后到现在的运行时间 。（实际上是以WIN32上QueryPerformanceCounter()为基础，它比毫秒表示更为精确）



二，用法及总结
1，在Windows中 ， time.clock()更精确；
2，这两个函数不可以混合使用；

python 计算时间差秒python 计算时间差秒：Q:如何方便的计算两个时间的差，如两个时间相差几天 ， 几小时等A:使用datetime模块可以很方便的解决这个问题，举例如下：上例演示了计算两个日期相差天数的计算 。上例演示了计算运行时间的例子，以秒进行显示 。上例演示了计算当前时间向后10小时的时间 。拓展：其本上常用的类有：datetime和timedelta两个 。它们之间可以相互加减 。每个类都有一些方法和属性可以查看具体的值，如datetime可以查看：天数(day) ， 小时数(hour)，星期几(weekday())等;timedelta可以查看：天数(days) ， 秒数(seconds)等 。
C++的time和localtime的函数 怎么用？仔细查看MSDN，把下边的例子敲一遍就明白了 ， 很简单的，在这里给你说的再多，也没有MSDN上更详细，更权威 。

C语言关于localtime_s()和asctime_s()两个函数的用法 。1、localtime函数：原型：struct tm * localtime(const time_t * clock)；功能：把从1970-1-1零点零分到当前时间系统所偏移的秒数时间转换为本地时间, 其中clock为秒数时间；返回值：返回一个tm结构体的指针 。tm结构体是time.h中定义的用于分别存储时间的各个量(年月日等)的结构体 。2、asctime函数：原型：char* asctime (const struct tm * timeptr)；功能：把timeptr指向的tm结构体中储存的时间转换为字符串；返回值：一个固定格式的字符串 。字符串格式为：Www Mmm dd hh:mm:ss yyyy 。其中Www为星期，Mmm为月份 ， dd为日 ， hh为时，mm为分，ss为秒，yyyy为年份；3、例程：#include#includeint main(){time_t rawtime;struct tm * timeinfo;time(&rawtime);timeinfo = localtime(&rawtime);//使用localtime函数把秒数时间rawtime转换为本地时间以tm结构体保存，并把tm结构体地址储存到timeinfo当中printf("当前日期为: %s",asctime(timeinfo));//使用asctime函数把tm结构体中储存的时间转换为字符串，并输出return 0;}

C++ swprintf_s()函数的用法"首先,swprintf_s()不是标准的C++函数,它是VC++特有的标准的int swprintf(wchar_t *buffer, const wchar_t *format[, argument, ...]);是sprintf的宽字符版而sprintf又是printf的改进版还是给你个EX:#include int main(void){wchar_t buffer[80];int x=1234;swprintf_s(buffer,80, L""x=%d\n"", x); //将x=1234输出到bufferwprintf(buffer);return 0;}"

C++中是localtime()函数将计时起点从1970年改为1900年开始的吗？localtime是 把从1970-1-1零点零分到当前时间系统所偏移的秒数时间转换为本地时间

大声的问：linux下C如何才能把当前位置的当前时间转换成字符串，有会的木有？求解决?。。⌒涣死瞺~当前位置的时间是什么意思呢？系统当前时间？
time_t now;
struct tm* timeinfo;
char buf[48];

time(&now);
timeinfo = localtime(&now);
bzero(buf,48);
//2013-02-27 16:38:33这是转化的格式，你随便怎么写都成反正是拼接
sprintf(buf,"%4d-%02d-%02d %02d:%02d:%02d",1900+timeinfo->tm_year, 1+timeinfo->tm_mon,timeinfo->tm_mday,timeinfo->tm_hour,timeinfo->tm_min,timeinfo->tm_sec);

这样当前时间就在buf里面了 。这事获得当前时间 。
如果你要获得各种时区的时间那么用NTP服务同步一下就行了 。
对了别忘了头文件?。约簃an一下time（）就能找到头文件了

linux中获取时间的几种方法asctime（将时间和日期以字符串格式表示）

相关函数
time，ctime ， gmtime，localtime

表头文件
#include

定义函数
char * asctime(const struct tm * timeptr);

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

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

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

范例
#include
main()
{
time_t timep;
time (&timep);
printf(“%s”,asctime(gmtime(&timep)));
}

执行
Sat Oct 28 02:10:06 2000

ctime（将时间和日期以字符串格式表示）

相关函数
time ， asctime，gmtime，localtime

表头文件
#include

定义函数
char *ctime(const time_t *timep);

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

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

范例
#include
main()
{
time_t timep;
time (&timep);
printf(“%s”,ctime(&timep));
}

执行
Sat Oct 28 10 : 12 : 05 2000

gettimeofday（取得目前的时间）

相关函数
time ， ctime，ftime，settimeofday

表头文件
#include
#include

定义函数
int gettimeofday ( struct timeval * tv , struct timezone * tz )

函数说明
gettimeofday()会把目前的时间有tv所指的结构返回 ， 当地时区的信息则放到tz所指的结构中 。
timeval结构定义为:
struct timeval{
long tv_sec; /*秒*/
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
#include
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

gmtime（取得目前时间和日期）

相关函数
time,asctime,ctime,localtime

表头文件
#include

定义函数
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
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

localtime（取得当地目前时间和日期）

相关函数
time, asctime, ctime, gmtime

表头文件
#include

定义函数
struct tm *localtime(const time_t * timep);

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

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

范例
#include
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

mktime（将时间结构数据转换成经过的秒数）

相关函数
time，asctime，gmtime，localtime

表头文件
#include

定义函数
time_t mktime(strcut tm * timeptr);

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

返回值
返回经过的秒数 。

范例
/* 用time()取得时间（秒数），利用localtime()
转换成struct tm 再利用mktine（）将struct tm转换成原来的秒数*/
#include
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

settimeofday（设置目前时间）

相关函数
time，ctime，ftime ， gettimeofday

表头文件
#include
#include

定义函数
int settimeofday ( const struct timeval *tv,const struct timezone *tz);

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

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

错误代码
EPERM 并非由root权限调用settimeofday（），权限不够 。
EINVAL 时区或某个数据是不正确的，无法正确设置时间 。

time（取得目前的时间）

相关函数
ctime ， ftime，gettimeofday

表头文件
#include

定义函数
time_t time(time_t *t);

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

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

范例
#include
mian()
{
int seconds= time((time_t*)NULL);
printf(“%d\n”,seconds);
}

linux中的time函数怎么实现的？利用什么原理或器件来得到秒数的？asctimeeHPLinux联盟
ctimeeHPLinux联盟
gettimeofdayeHPLinux联盟
gmtimeeHPLinux联盟
localtimeeHPLinux联盟
mktimeeHPLinux联盟
settimeofdayeHPLinux联盟
timeeHPLinux联盟
asctime（将时间和日期以字符串格式表示） 相关函数 time，ctime ， gmtime，localtimeeHPLinux联盟
表头文件 #includeeHPLinux联盟
定义函数 char * asctime(const struct tm * timeptr);eHPLinux联盟
函数说明 asctime()将参数timeptr所指的tm结构中的信息转换成真实世界所使用的时间日期表示方法，然后将结果以字符串形态返回 。此函数已经由时区转换成当地时间，字符串格式为:“Wed Jun 30 21:49:08 1993\n”eHPLinux联盟
返回值 若再调用相关的时间日期函数，此字符串可能会被破坏 。此函数与ctime不同处在于传入的参数是不同的结构 。eHPLinux联盟
附加说明 返回一字符串表示目前当地的时间日期 。eHPLinux联盟
范例 #include eHPLinux联盟
main()eHPLinux联盟
{eHPLinux联盟time_t timep;eHPLinux联盟time (&timep);eHPLinux联盟printf(“%s”,asctime(gmtime(&timep)));eHPLinux联盟}eHPLinux联盟
执行 Sat Oct 28 02:10:06 2000eHPLinux联盟
eHPLinux联盟
eHPLinux联盟
eHPLinux联盟
ctime（将时间和日期以字符串格式表示） 相关函数 time ， asctime ， gmtime ， localtimeeHPLinux联盟
表头文件 #includeeHPLinux联盟
定义函数 char *ctime(const time_t *timep);eHPLinux联盟
函数说明 ctime()将参数timep所指的time_t结构中的信息转换成真实世界所使用的时间日期表示方法，然后将结果以字符串形态返回 。此函数已经由时区转换成当地时间，字符串格式为“Wed Jun 30 21 :49 :08 1993\n” 。若再调用相关的时间日期函数，此字符串可能会被破坏 。eHPLinux联盟
返回值 返回一字符串表示目前当地的时间日期 。eHPLinux联盟
范例 #includeeHPLinux联盟
main()eHPLinux联盟
{eHPLinux联盟time_t timep;eHPLinux联盟time (&timep);eHPLinux联盟printf(“%s”,ctime(&timep));eHPLinux联盟}eHPLinux联盟
执行 Sat Oct 28 10 : 12 : 05 2000eHPLinux联盟
eHPLinux联盟
eHPLinux联盟
eHPLinux联盟
gettimeofday（取得目前的时间） 相关函数 time，ctime ， ftime，settimeofdayeHPLinux联盟
表头文件 #include eHPLinux联盟
#include eHPLinux联盟
定义函数 int gettimeofday ( struct timeval * tv , struct timezone * tz )eHPLinux联盟
函数说明 gettimeofday()会把目前的时间有tv所指的结构返回，当地时区的信息则放到tz所指的结构中 。eHPLinux联盟
timeval结构定义为:eHPLinux联盟
struct timeval{eHPLinux联盟long tv_sec; /*秒*/eHPLinux联盟long tv_usec; /*微秒*/eHPLinux联盟};eHPLinux联盟
timezone 结构定义为:eHPLinux联盟
struct timezone{eHPLinux联盟int tz_minuteswest; /*和Greenwich 时间差了多少分钟*/eHPLinux联盟int tz_dsttime; /*日光节约时间的状态*/eHPLinux联盟};eHPLinux联盟
上述两个结构都定义在/usr/include/sys/time.h 。tz_dsttime 所代表的状态如下eHPLinux联盟
DST_NONE /*不使用*/eHPLinux联盟
DST_USA /*美国*/eHPLinux联盟
DST_AUST /*澳洲*/eHPLinux联盟
DST_WET /*西欧*/eHPLinux联盟
DST_MET /*中欧*/eHPLinux联盟
DST_EET /*东欧*/eHPLinux联盟
DST_CAN /*加拿大*/eHPLinux联盟
DST_GB /*大不列颠*/eHPLinux联盟
DST_RUM /*罗马尼亚*/eHPLinux联盟
DST_TUR /*土耳其*/eHPLinux联盟
DST_AUSTALT /*澳洲（1986年以后）*/eHPLinux联盟
返回值 成功则返回0，失败返回－1，错误代码存于errno 。附加说明EFAULT指针tv和tz所指的内存空间超出存取权限 。eHPLinux联盟
范例 #includeeHPLinux联盟
#includeeHPLinux联盟
main(){eHPLinux联盟struct timeval tv;eHPLinux联盟struct timezone tz;eHPLinux联盟gettimeofday (&tv , &tz);eHPLinux联盟printf(“tv_sec; %d\n”, tv,.tv_sec) ;eHPLinux联盟printf(“tv_usec; %d\n”,tv.tv_usec);eHPLinux联盟printf(“tz_minuteswest; %d\n”, tz.tz_minuteswest);eHPLinux联盟printf(“tz_dsttime, %d\n”,tz.tz_dsttime);eHPLinux联盟}eHPLinux联盟
执行 tv_sec: 974857339eHPLinux联盟
tv_usec:136996eHPLinux联盟
tz_minuteswest:-540eHPLinux联盟
tz_dsttime:0eHPLinux联盟
eHPLinux联盟
eHPLinux联盟
eHPLinux联盟
gmtime（取得目前时间和日期） 相关函数 time,asctime,ctime,localtimeeHPLinux联盟
表头文件 #includeeHPLinux联盟
定义函数 struct tm*gmtime(const time_t*timep);eHPLinux联盟
函数说明 gmtime()将参数timep 所指的time_t 结构中的信息转换成真实世界所使用的时间日期表示方法，然后将结果由结构tm返回 。eHPLinux联盟
结构tm的定义为eHPLinux联盟
struct tmeHPLinux联盟
{eHPLinux联盟int tm_sec;eHPLinux联盟int tm_min;eHPLinux联盟int tm_hour;eHPLinux联盟int tm_mday;eHPLinux联盟int tm_mon;eHPLinux联盟int tm_year;eHPLinux联盟int tm_wday;eHPLinux联盟int tm_yday;eHPLinux联盟int tm_isdst;eHPLinux联盟};eHPLinux联盟
int tm_sec 代表目前秒数，正常范围为0-59 ， 但允许至61秒eHPLinux联盟
int tm_min 代表目前分数，范围0-59eHPLinux联盟
int tm_hour 从午夜算起的时数，范围为0-23eHPLinux联盟
int tm_mday 目前月份的日数，范围01-31eHPLinux联盟
int tm_mon 代表目前月份，从一月算起 ， 范围从0-11eHPLinux联盟
int tm_year 从1900 年算起至今的年数eHPLinux联盟
int tm_wday 一星期的日数 ， 从星期一算起，范围为0-6eHPLinux联盟
int tm_yday 从今年1月1日算起至今的天数，范围为0-365eHPLinux联盟
int tm_isdst 日光节约时间的旗标eHPLinux联盟
此函数返回的时间日期未经时区转换 ， 而是UTC时间 。eHPLinux联盟
返回值 返回结构tm代表目前UTC 时间eHPLinux联盟
范例 #include eHPLinux联盟
main(){eHPLinux联盟char *wday[]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};eHPLinux联盟
time_t timep;eHPLinux联盟
struct tm *p;eHPLinux联盟
time(&timep);eHPLinux联盟
p=gmtime(&timep);eHPLinux联盟
printf(“%d%d%d”,(1900+p->tm_year), (1+p->tm_mon),p->tm_mday);eHPLinux联盟
printf(“%s%d;%d;%d\n”, wday[p->tm_wday], p->tm_hour, p->tm_min, p->tm_sec);eHPLinux联盟
}eHPLinux联盟
执行 2000/10/28 Sat 8:15:38eHPLinux联盟
eHPLinux联盟
eHPLinux联盟
eHPLinux联盟
localtime（取得当地目前时间和日期） 相关函数 time, asctime, ctime, gmtimeeHPLinux联盟
表头文件 #includeeHPLinux联盟
定义函数 struct tm *localtime(const time_t * timep);eHPLinux联盟
函数说明 localtime()将参数timep所指的time_t结构中的信息转换成真实世界所使用的时间日期表示方法，然后将结果由结构tm返回 。结构tm的定义请参考gmtime() 。此函数返回的时间日期已经转换成当地时区 。eHPLinux联盟
返回值 返回结构tm代表目前的当地时间 。eHPLinux联盟
范例 #includeeHPLinux联盟
main(){eHPLinux联盟char *wday[]={“Sun”,”Mon”,”Tue”,”Wed”,”Thu”,”Fri”,”Sat”};eHPLinux联盟
time_t timep;eHPLinux联盟
struct tm *p;eHPLinux联盟
time(&timep);eHPLinux联盟
p=localtime(&timep); /*取得当地时间*/eHPLinux联盟
printf (“%d%d%d ”, (1900+p->tm_year),( l+p->tm_mon), p->tm_mday);eHPLinux联盟
printf(“%s%d:%d:%d\n”, wday[p->tm_wday],p->tm_hour, p->tm_min, p->tm_sec);eHPLinux联盟
}eHPLinux联盟
执行 2000/10/28 Sat 11:12:22eHPLinux联盟
eHPLinux联盟
eHPLinux联盟
eHPLinux联盟
mktime（将时间结构数据转换成经过的秒数） 相关函数 time ， asctime，gmtime ， localtimeeHPLinux联盟
表头文件 #includeeHPLinux联盟
定义函数 time_t mktime(strcut tm * timeptr);eHPLinux联盟
函数说明 mktime()用来将参数timeptr所指的tm结构数据转换成从公元1970年1月1日0时0分0 秒算起至今的UTC时间所经过的秒数 。eHPLinux联盟
返回值 返回经过的秒数 。eHPLinux联盟
范例 /* 用time()取得时间（秒数），利用localtime()eHPLinux联盟
转换成struct tm 再利用mktine（）将struct tm转换成原来的秒数*/eHPLinux联盟
#includeeHPLinux联盟
main()eHPLinux联盟
{eHPLinux联盟time_t timep;eHPLinux联盟strcut tm *p;eHPLinux联盟time(&timep);eHPLinux联盟printf(“time() : %d \n”,timep);eHPLinux联盟p=localtime(&timep);eHPLinux联盟timep = mktime(p);eHPLinux联盟printf(“time()->localtime()->mktime():%d\n”,timep);eHPLinux联盟}eHPLinux联盟
执行 time():974943297eHPLinux联盟
time()->localtime()->mktime():974943297eHPLinux联盟
eHPLinux联盟
eHPLinux联盟
eHPLinux联盟
settimeofday（设置目前时间） 相关函数 time，ctime，ftime，gettimeofdayeHPLinux联盟
表头文件 #includeeHPLinux联盟
#includeeHPLinux联盟
定义函数 int settimeofday ( const struct timeval *tv,const struct timezone *tz);eHPLinux联盟
函数说明 settimeofday()会把目前时间设成由tv所指的结构信息，当地时区信息则设成tz所指的结构 。详细的说明请参考gettimeofday() 。注意，只有root权限才能使用此函数修改时间 。eHPLinux联盟
返回值 成功则返回0，失败返回－1 ， 错误代码存于errno 。eHPLinux联盟
错误代码 EPERM 并非由root权限调用settimeofday（），权限不够 。eHPLinux联盟
EINVAL 时区或某个数据是不正确的，无法正确设置时间 。eHPLinux联盟
eHPLinux联盟
eHPLinux联盟
eHPLinux联盟
time（取得目前的时间） 相关函数 ctime，ftime，gettimeofdayeHPLinux联盟
表头文件 #includeeHPLinux联盟
定义函数 time_t time(time_t *t);eHPLinux联盟
函数说明 此函数会返回从公元1970年1月1日的UTC时间从0时0分0秒算起到现在所经过的秒数 。如果t 并非空指针的话，此函数也会将返回值存到t指针所指的内存 。eHPLinux联盟
返回值 成功则返回秒数 ， 失败则返回((time_t)-1)值，错误原因存于errno中 。eHPLinux联盟
范例 #includeeHPLinux联盟
mian()eHPLinux联盟
{eHPLinux联盟int seconds= time((time_t*)NULL);eHPLinux联盟printf(“%d\n”,seconds);eHPLinux联盟}eHPLinux联盟
执行 9.73E+08

c语言linux帮写小段取当前时间的codelinxu上有提供相应的c语言的接口比如time函数使用time函数可以获取一个时间戳该时间戳是1870年1月1日0：0：0至现在的秒数然后我们可以使用linux提供的一些转换接口将其转换为时分秒的格式比如ctime或者也可以使用gmtime或者localtime将其转换为struct tm结构体的数据我们同样也可以使用gettimeofday函数来获取时间比如一个简单的代码实现如下#include #include #include int main(int argc,char **argv){time_t t;struct tm *m;if((t=time(NULL)) == (time_t)-1){perror("time");return -1;}m=localtime(&t);printf("%.2d:%.2d:%.2d\n",m->tm_hour,m->tm_min,m->tm_sec);return 0;}

gettimeofday()和time()的区别是什么？gettimeofday()和time()的区别就是 ， time(); 当前时间的UNIX时间戳，也就是从有UNIX开始到现在的秒数 。gettimeofday(); 内置函数生成的数组 。一、gettimeofday是计算机函数，使用C语言编写程序需要获得当前精确时间（1970年1月1日到现在的时间），或者为执行计时，可以使用gettimeofday()函数 。二、#include int gettimeofday(struct timeval*tv, struct timezone *tz);其参数tv是保存获取时间结果的结构体，参数tz用于保存时区结果：struct timezone{int tz_minuteswest;/*格林威治时间往西方的时差*/int tz_dsttime;/*DST 时间的修正方式*/}timezone 参数若不使用则传入NULL即可 。三、本函数是 gettimeofday(2) 的接口 。返回一个关联数组，包含有系统调用返回的数据 。自 PHP 5.1.0 起有个可选参数 return_float，当其设为 TRUE 时，gettimeofday() 会返回一个浮点数 。四、time() 是指返回自 Unix 纪元（January 1 1970 00:00:00 GMT）起的当前时间的秒数的函数 ， 主要用来获取当前的系统时间，返回的结果是一个time_t类型 。五、其值表示从UTC（Coordinated Universal Time）时间1970年1月1日00:00:00（称为UNIX系统的Epoch时间）到当前时刻的秒数 。然后调用localtime函数将time_t所表示的UTC时间转换为本地时间（我们是+8区，比UTC多8个小时）并转成struct tm类型，该类型的各数据成员分别表示年月日时分秒 。
C语言时间，怎么把time_t类型的时间 ， 转化成年、月、日、时、分、秒呢？可以使用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
#include
int main()
{
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;
}
注意：p=gmtime(&t);此行若改为p=localtime(&t);则返回当前时区的时间 。

如何获得比localtime更大的时间范围typedef struct _FILETIME {
DWORD dwLowDateTime;
DWORD dwHighDateTime;
} FILETIME, *PFILETIME, *LPFILETIME;

typedef struct _SYSTEMTIME {
WORD wYear;
WORD wMonth;
WORD wDayOfWeek;
WORD wDay;
WORD wHour;
WORD wMinute;
WORD wSecond;
WORD wMilliseconds;
} SYSTEMTIME, *LPSYSTEMTIME;
FILETIME和SYSTEMTIME都只是记录时间的结构 。
GetLocalTime能够得到本地电脑设置时区的时间，得到的类型是SYSTEMTIME的类型 。

C语言功能：获取当前日期时间#include
#include
int main()
{
time_t timep;
struct tm *p;
time(&timep);
p = localtime(&timep); //此函数获得的tm结构体的时间，是已经进行过时区转化为本地时间

printf("%d%02d%02d%02d%02d%02d\n", 1900+p->tm_year, 1+p->tm_mon, p->tm_mday, p->tm_hour,p->tm_min, p->tm_sec);
return 0;
}

C语言中取得当地时间范围问题#include
#include
int main( void )
{
time_t t = time(0);
char tmp[64];
strftime( tmp, sizeof(tmp), "%Y/%m/%d %X %A 本年第%j天 %z",localtime(&t) );
puts( tmp );
return 0;
}
size_t strftime(char *strDest, size_t maxsize, const char *format, const struct tm *timeptr);
根据格式字符串生成字符串 。
struct tm *localtime(const time_t *timer);
取得当地时间，localtime获取的结果由结构tm返回
返回的字符串可以依下列的格式而定：
%a 星期几的缩写 。Eg:Tue
%A 星期几的全名 。Eg: Tuesday
%b 月份名称的缩写 。
%B 月份名称的全名 。
%c 本地端日期时间较佳表示字符串 。
%d 用数字表示本月的第几天 (范围为 00 至 31) 。日期
%H 用 24 小时制数字表示小时数 (范围为 00 至 23) 。
%I 用 12 小时制数字表示小时数 (范围为 01 至 12) 。
%j 以数字表示当年度的第几天 (范围为 001 至 366) 。
%m 月份的数字 (范围由 1 至 12) 。
%M 分钟 。
%p 以 ''AM'' 或 ''PM'' 表示本地端时间 。
%S 秒数 。
%U 数字表示为本年度的第几周，第一个星期由第一个周日开始 。
%W 数字表示为本年度的第几周，第一个星期由第一个周一开始 。
%w 用数字表示本周的第几天 ( 0 为周日) 。
%x 不含时间的日期表示法 。
%X 不含日期的时间表示法 。Eg: 15:26:30
%y 二位数字表示年份 (范围由 00 至 99) 。
%Y 完整的年份数字表示 ， 即四位数 。Eg:2008
%Z(%z) 时区或名称缩写 。Eg:中国标准时间
%% % 字符 。

//方案二 优点：能精确到毫秒级；缺点：使用了windows API
#include
#include
int main( void )
{
SYSTEMTIME sys;
GetLocalTime( &sys );
printf( "%4d/%02d/%02d %02d:%02d:%02d.%03d 星期%1d\n",sys.wYear,sys.wMonth,sys.wDay,sys.wHour,sys.wMinute, sys.wSecond,sys.wMilliseconds,sys.wDayOfWeek);
return 0;
}

//方案三,优点：利用系统函数,还能修改系统时间
//此文件必须是c++文件
#include
#include
using namespace std;
void main()
{
system("time");
}

//方案四,将当前时间折算为秒级，再通过相应的时间换算即可
//此文件必须是c++文件
#include
#include
using namespace std;
int main()
{
time_t now_time;
now_time = time(NULL);
cout<<now_time;
return 0;
}

• 动漫人物简笔画
• 衣服发黄怎么洗才能发白 你值得了解的方法
• 奶茶店制冰机价格
• 如何快速了解一个人的三观 怎么才能了解一个人的三观
• 如何了解一个人的三观 怎么快速了解一个人的三观
• 怎么清理苹果手机听筒的灰尘 iphone听筒进灰尘了解决方法
• 无法删除文件
• 办理5万额度信用卡
• 古典音乐入门
• 砂浆王起到什么作用 带你了解砂浆王的作用及危害