【C/C++】C语言获取日期时间|sleep休眠|time|sleep函数
目录
统计时间
Windows &&linux通用
high_resolution_clock
C++使用chrono获取时间差
#include <iostream>
#include <chrono>
int main(){
auto start = std::chrono::high_resolution_clock::now();
int res = 1;
for(int i=0; i<100000; i++){
res++;
}
auto end = std::chrono::high_resolution_clock::now();
std::chrono::duration<double, std::milli> tm = end - start; // 毫秒
// std::chrono::duration<double, std::micro> tm = end - start; 微秒
std::cout << "time: " << tm.count() << "ms" << std::endl;
return 0;
}Windows环境
1. 获取当前时间，可精确到秒（Windows）
获取时间
1 使用 time_t time( time_t * timer ) 精确到秒
3 计算时间差使用 double difftime( time_t timer1, time_t timer0 )
#include <iostream>
#include <ctime>
int main(){
time_t tv;
tv = time(NULL);//time(&tv); get current time;
std::cout << tv << std::endl;//距离1970-01-01 00:00:00经历的秒数
std::cout << ctime(&tv) << std::endl;//显示当前时间
tm *local;
local = localtime(&tv);
std::cout << asctime(local) << std::endl;//显示当前时
return 0;
}
2.精确到毫秒
4 使用 DWORD GetTickCount() 精确到毫秒
(1).<windows.h>
<windows.h>
#include <iostream>
#include <windows.h>
int main(){
DWORD t_start, t_end;
t_start = GetTickCount();//从操作系统启动所经过（elapsed）的毫秒数，它的返回值是DWORD。
Sleep(3000);
t_end = GetTickCount();
std::cout << t_end - t_start << std::endl;
return 0;
}
(2). <timeb.h>
#include <iostream>
#include <sys\timeb.h>
long long getSystemTime(){
timeb t;
ftime(&t);
return t.time * 1000 + t.millitm;
}
int main(){
long long t_start = getSystemTime();
Sleep(3000);
long long t_end = getSystemTime();
std::cout << t_end - t_start << std::endl;
return 0;
}
---------------------
原文：https://blog.csdn.net/kangruihuan/article/details/59055801
clock() 函数 , 用 clock() 函数，得到系统启动以后的毫秒级时间，然后除以 CLOCKS_PER_SEC ，就可以换成“秒”，标准 c 函数。
使用该函数可以得到启动到函数调用占用CPU的时间。这个函数返回从“启动程序进程”到“程序中调用clock()函数”时之间的CPU时钟计时单元（clock tick）数，其中clock_t是用来保存时间的数据类型。
#define CLOCKS_PER_SEC <integer constant expression > 0>
clock_t clock ( void );
#include clock_t t = clock();
long sec = t / CLOCKS_PER_SEC; (CLOCKS_PER_SEC 这个在头文件中找到定义）
他是记录时钟周期的，实现看来不会很精确，需要试验验证；
#include <time.h>
void main()
{
clock_t start_time, end_time;
start_time = clock(); //获取开始执行时间
xxxxxxx； //过程
end_time = clock(); //获取结束时间
double Times = (double)(end_time - start_time) / CLOCKS_PER_SEC;
printf("%f seconds\n", Times);
}
gettime(&t); 据说 tc2.0 的 time 结构含有毫秒信息
#include
#include
int main(void)
{
struct time t;
gettime(&t);
printf("The current time is: -:d:d.d/n",
t.ti_hour, t.ti_min, t.ti_sec, t.ti_hund);
return 0;
}
time 是一个结构体，， 其中成员函数 ti_hund 是毫秒。。。GetTickCount(), 这个是 windows 里面常用来计算程序运行时间的函数；
DWORD dwStart = GetTickCount();
// 这里运行你的程序代码
DWORD dwEnd = GetTickCount();
则 (dwEnd-dwStart) 就是你的程序运行时间 , 以毫秒为单位
这个函数只精确到 55ms ， 1 个 tick 就是 55ms 。
#include <iostream>
#include <windows.h>
void main()
{
long start_time = GetTickCount(); //获取开始执行时间
xxxxxxx； //过程
long end_time = GetTickCount(); //获取结束时间
long Times = end_time-start_time;
printf("%f seconds\n", Times);
}
timeGetTime()t,imeGetTime() 基本等于 GetTickCount() ，但是精度更高
DWORD dwStart = timeGetTime();
// 这里运行你的程序代码
DWORD dwEnd = timeGetTime();
则 (dwEnd-dwStart) 就是你的程序运行时间 , 以毫秒为单位
虽然返回的值单位应该是 ms, 但传说精度只有 10ms 。3.精确到1/CLOCKS_PER_SEC 秒等更高精度
2 使用 clock_t clock() 得到的是 CPU 时间 精确到 1/CLOCKS_PER_SEC 秒
6 要获取高精度时间，可以使用
BOOL QueryPerformanceFrequency(LARGE_INTEGER *lpFrequency)
获取系统的计数器的频率
BOOL QueryPerformanceCounter(LARGE_INTEGER *lpPerformanceCount)
获取计数器的值
然后用两次计数器的差除以 Frequency 就得到时间。
7 Multimedia Timer Functions
The following functions are used with multimedia timers.
timeBeginPeriod/timeEndPeriod/timeGetDevCaps/timeGetSystemTime
//*********************************************************************
// 用标准 C 实现获取当前系统时间的函数
一种制作微秒级精度定时器的方法
当使用定时器时，在很多情况下只用到毫秒级的时间间隔，所以只需用到下面的两种常用方式就满足要求了。一是用 SetTimer 函数建立一个定时器后，在程序中通过处理由定时器发送到线程消息队列中的 WM_TIMER 消息，而得到定时的效果（退出程序时别忘了调用和 SetTimer 配对使用的 KillTimer 函数）。二是利用 GetTickCount 函数可以返回自计算机启动后的时间，通过两次调用 GetTickCount 函数，然后控制它们的差值来取得定时效果，此方式跟第一种方式一样，精度也是毫秒级的。
用这两种方式取得的定时效果虽然在许多场合已经满足实际的要求，但由于它们的精度只有毫秒级的，而且在要求定时时间间隔小时，实际定时误差大。下面介绍一种能取得高精度定时的方法。
在一些计算机硬件系统中，包含有高精度运行计数器（ high-resolution performance counter ），利用它可以获得高精度定时间隔，其精度与 CPU 的时钟频率有关。采用这种方法的步骤如下：
1 、 首先调用 QueryPerformanceFrequency 函数取得高精度运行计数器的频率 f 。单位是每秒多少次（ n/s ），此数一般很大。
2 、 在需要定时的代码的两端分别调用 QueryPerformanceCounter 以取得高精度运行计数器的数值 n1 ， n2 。两次数值的差值通过 f 换算成时间间隔， t=(n2-n1)/f 。
下面举一个例子来演示这种方法的使用及它的精确度。
在 VC 6.0 下用 MFC 建立一个对话框工程，取名为 HightTimer. 在对话框面板中控件的布局如下图：
其中包含两个静态文本框，两个编辑框和两个按纽。上面和下面位置的编辑框的 ID 分别为 IDC_E_TEST 和 IDC_E_ACTUAL ，通过 MFC ClassWizard 添加的成员变量也分别对应为 DWORD m_dwTest 和 DWORD m_dwAct. “ 退出 ” 按纽的 ID 为 IDOK ， “ 开始测试 ” 按纽 ID 为 IDC_B_TEST ，用 MFC ClassWizard 添加此按纽的单击消息处理函数如下：
void CHightTimerDlg::OnBTest()
{
//TODO: Add your control notification handler code here
UpdateData(TRUE); // 取输入的测试时间值到与编辑框相关联的成员变量 m_dwTest 中
LARGE_INTEGER frequence;
if(!QueryPerformanceFrequency( &frequence)) // 取高精度运行计数器的频率，若硬件不支持则返回 FALSE
MessageBox("Your computer hardware doesn't support the high-resolution performance counter",
"Not Support", MB_ICONEXCLAMATION | MB_OK);
LARGE_INTEGER test, ret;
test.QuadPart = frequence.QuadPart * m_dwTest / 1000000; // 通过频率换算微秒数到对应的数量（与 CPU 时钟有关）， 1 秒 =1000000 微秒
ret = MySleep( test ); // 调用此函数开始延时，返回实际花销的数量
m_dwAct = (DWORD)(1000000 * ret.QuadPart / frequence.QuadPart ); // 换算到微秒数
UpdateData(FALSE); // 显示到对话框面板
}其中上面调用的 MySleep 函数如下：
LARGE_INTEGER CHightTimerDlg::MySleep(LARGE_INTEGER Interval)
/
// 功能：执行实际的延时功能
// 参数： Interval 参数为需要执行的延时与时间有关的数量
// 返回值：返回此函数执行后实际所用的时间有关的数量
///{
LARGE_INTEGER privious, current, Elapse;
QueryPerformanceCounter( &privious );
current = privious;
while( current.QuadPart - privious.QuadPart < Interval.QuadPart )
QueryPerformanceCounter( ¤t );
Elapse.QuadPart = current.QuadPart - privious.QuadPart;
return Elapse;
}
注：别忘了在头文件中为此函数添加函数声明。
至此，可以编译和执行此工程了，结果如上图所示。在本人所用的机上 ( 奔腾 366 ， 64M 内存 ) 测试，当测试时间超过 3 微秒时，准确度已经非常高了，此时机器执行本身延时函数代码的时间对需要延时的时间影响很小了。
上面的函数由于演示测试的需要，没有在函数级封装，下面给出的函数基本上可以以全局函数的形式照搬到别的程序中。
BOOL MySleep(DWORD dwInterval)
/
// 功能：执行微秒级的延时功能
// 参数： Interval 参数为需要的延时数（单位：微秒）
// 返回值：若计算机硬件不支持此功能，返回 FALSE ，若函数执行成功，返回 TRUE
///{
BOOL bNormal = TRUE;
LARGE_INTEGER frequence, privious, current, interval;
if(!QueryPerformanceFrequency( &frequence))
{
::MessageBox(NULL, "Your computer hardware doesn't support the high-resolution performance counter",
"Not Support", MB_ICONEXCLAMATION | MB_OK); // 或其它的提示信息
return FALSE;
}
interval.QuadPart = frequence.QuadPart * dwInterval / 1000000;
bNormal = bNormal && QueryPerformanceCounter( &privious );
current = privious;
while( current.QuadPart - privious.QuadPart < interval.QuadPart )
bNormal = bNormal && QueryPerformanceCounter( ¤t );
return bNormal;
}
需要指出的是，由于在此函数中的代码很多，机器在执行这些代码所花费的时间也很长，所以在需要几个微秒的延时时，会影响精度。实际上，读者在熟悉这种方法后，只要使用 QueryPerformanceFrequency 和 QueryPerformanceCounter 这两个函数就能按实际需要写出自己的延时代码了。
使用 CPU 时间戳进行高精度计时
对关注性能的程序开发人员而言，一个好的计时部件既是益友，也是良师。计时器既可以作为程序组件帮助程序员精确的控制程序进程，又是一件有力的调试武器，在有经验的程序员手里可以尽快的确定程序的性能瓶颈，或者对不同的算法作出有说服力的性能比较。
在 Windows 平台下，常用的计时器有两种，一种是 timeGetTime 多媒体计时器，它可以提供毫秒级的计时。但这个精度对很多应用场合而言还是太粗糙了。另一种是 QueryPerformanceCount 计数器，随系统的不同可以提供微秒级的计数。对于实时图形处理、多媒体数据流处理、或者实时系统构造的程序员，善用 QueryPerformanceCount/QueryPerformanceFrequency 是一项基本功。
本文要介绍的，是另一种直接利用 Pentium CPU 内部时间戳进行计时的高精度计时手段。以下讨论主要得益于《 Windows 图形编程》一书，第 15 页－ 17 页，有兴趣的读者可以直接参考该书。关于 RDTSC 指令的详细讨论，可以参考 Intel 产品手册。本文仅仅作抛砖之用。
在 Intel Pentium 以上级别的 CPU 中，有一个称为 “ 时间戳（ Time Stamp ） ” 的部件，它以 64 位无符号整型数的格式，记录了自 CPU 上电以来所经过的时钟周期数。由于目前的 CPU 主频都非常高，因此这个部件可以达到纳秒级的计时精度。这个精确性是上述两种方法所无法比拟的。
在 Pentium 以上的 CPU 中，提供了一条机器指令 RDTSC （ Read Time Stamp Counter ）来读取这个时间戳的数字，并将其保存在 EDX:EAX 寄存器对中。由于 EDX:EAX 寄存器对恰好是 Win32 平台下 C++ 语言保存函数返回值的寄存器，所以我们可以把这条指令看成是一个普通的函数调用。像这样：
inline unsigned __int64 GetCycleCount()
{
__asm RDTSC
}
但是不行，因为 RDTSC 不被 C++ 的内嵌汇编器直接支持，所以我们要用 _emit 伪指令直接嵌入该指令的机器码形式 0X0F 、 0X31 ，如下：
inline unsigned __int64 GetCycleCount()
{
__asm _emit 0x0F
__asm _emit 0x31
}
以后在需要计数器的场合，可以像使用普通的 Win32 API 一样，调用两次 GetCycleCount 函数，比较两个返回值的差，像这样：
unsigned long t;
t = (unsigned long)GetCycleCount();
//Do Something time-intensive ...
t -= (unsigned long)GetCycleCount();
《 Windows 图形编程》第 15 页编写了一个类，把这个计数器封装起来。有兴趣的读者可以去参考那个类的代码。作者为了更精确的定时，做了一点小小的改进，把执行 RDTSC 指令的时间，通过连续两次调用 GetCycleCount 函数计算出来并保存了起来，以后每次计时结束后，都从实际得到的计数中减掉这一小段时间，以得到更准确的计时数字。但我个人觉得这一点点改进意义不大。在我的机器上实测，这条指令大概花掉了几十到 100 多个周期，在 Celeron 800MHz 的机器上，这不过是十分之一微秒的时间。对大多数应用来说，这点时间完全可以忽略不计；而对那些确实要精确到纳秒数量级的应用来说，这个补偿也过于粗糙了。
这个方法的优点是：
1. 高精度。可以直接达到纳秒级的计时精度（在 1GHz 的 CPU 上每个时钟周期就是一纳秒），这是其他计时方法所难以企及的。
2. 成本低。 timeGetTime 函数需要链接多媒体库 winmm.lib ， QueryPerformance* 函数根据 MSDN 的说明，需要硬件的支持（虽然我还没有见过不支持的机器）和 KERNEL 库的支持，所以二者都只能在 Windows 平台下使用（关于 DOS 平台下的高精度计时问题，可以参考《图形程序开发人员指南》，里面有关于控制定时器 8253 的详细说明）。但 RDTSC 指令是一条 CPU 指令，凡是 i386 平台下 Pentium 以上的机器均支持，甚至没有平台的限制（我相信 i386 版本 UNIX 和 Linux 下这个方法同样适用，但没有条件试验），而且函数调用的开销是最小的。
3. 具有和 CPU 主频直接对应的速率关系。一个计数相当于 1/(CPU 主频 Hz 数 ) 秒，这样只要知道了 CPU 的主频，可以直接计算出时间。这和 QueryPerformanceCount 不同，后者需要通过 QueryPerformanceFrequency 获取当前计数器每秒的计数次数才能换算成时间。
这个方法的缺点是：
1. 现有的 C/C++ 编译器多数不直接支持使用 RDTSC 指令，需要用直接嵌入机器码的方式编程，比较麻烦。
2. 数据抖动比较厉害。其实对任何计量手段而言，精度和稳定性永远是一对矛盾。如果用低精度的 timeGetTime 来计时，基本上每次计时的结果都是相同的；而 RDTSC 指令每次结果都不一样，经常有几百甚至上千的差距。这是这种方法高精度本身固有的矛盾。
关于这个方法计时的最大长度，我们可以简单的用下列公式计算：
自 CPU 上电以来的秒数 = RDTSC 读出的周期数 / CPU 主频速率（ Hz ）
64 位无符号整数所能表达的最大数字是 1.8×10^19 ，在我的 Celeron 800 上可以计时大约 700 年（书中说可以在 200MHz 的 Pentium 上计时 117 年，这个数字不知道是怎么得出来的，与我的计算有出入）。无论如何，我们大可不必关心溢出的问题。
下面是几个小例子，简要比较了三种计时方法的用法与精度
//Timer1.cpp 使用了 RDTSC 指令的 Timer 类 //KTimer 类的定义可以参见《 Windows 图形编程》 P15
// 编译行： CL Timer1.cpp /link USER32.lib
#include <stdio.h>
#include "KTimer.h"
main()
{
unsigned t;
KTimer timer;
timer.Start();
Sleep(1000);
t = timer.Stop();
printf("Lasting Time: %d/n",t);
}
Unix环境
##unix 时间相关 , 也是标准库的
1.timegm 函数只是将 struct tm 结构转成 time_t 结构 , 不使用时区信息 ;
time_t timegm(struct tm *tm);
2.mktime 使用时区信息
time_t mktime(struct tm *tm);
timelocal 函数是 GNU 扩展的与 posix 函数 mktime 相当
time_t timelocal (struct tm *tm);
3.gmtime 函数只是将 time_t 结构转成 struct tm 结构 , 不使用时区信息 ;
struct tm * gmtime(const time_t *clock);
4.localtime 使用时区信息
struct tm * localtime(const time_t *clock);
1.time 获取时间， stime 设置时间
time_t t ；
t = time(&t);
2.stime 其参数应该是 GMT 时间 , 根据本地时区设置为本地时间 ;
int stime(time_t *tp)
3.UTC=true 表示采用夏时制 ;
4. 文件的修改时间等信息全部采用 GMT 时间存放 , 不同的系统在得到修改时间后通过 localtime 转换成本地时间 ;
5. 设置时区推荐使用 setup 来设置 ;
6. 设置时区也可以先更变 /etc/sysconfig/clock 中的设置 再将 ln -fs /usr/share/zoneinfo/xxxx/xxx /etc/localtime 才能重效
time_t 只能表示 68 年的范围，即 mktime 只能返回 1970-2038 这一段范围的 time_t
看看你的系统是否有 time_t64 ，它能表示更大的时间范围
VS界面查看运行时间统计
调试-->窗口-->显示诊断工具
VC环境
//***************************************************************windows
##Window 里面的一些不一样的
//*********************************************************************
一 .CTime () 类
VC 编程一般使用 CTime 类 获得当前日期和时间
CTime t = GetCurrentTime();
SYSTEMTIME 结构包含毫秒信息
typedef struct _SYSTEMTIME
{
WORD wYear;
WORD wMonth;
WORD wDayOfWeek;
WORD wDay;
WORD wHour;
WORD wMinute;
WORD wSecond;
WORD wMilliseconds;
} SYSTEMTIME, *PSYSTEMTIME;
SYSTEMTIME t1;
GetSystemTime(&t1)
CTime curTime(t1);
WORD ms = t1.wMilliseconds;
SYSTEMTIME sysTm;
::GetLocalTime(&sysTm);
在 time.h 中的 _strtime() // 只能在 windows 中用
char t[11];
_strtime(t);
puts(t);获得当前日期和时间
CTime tm=CTime::GetCurrentTime();
CString str=tm.Format("%Y-%m-%d");
在 VC 中，我们可以借助 CTime 时间类，获取系统当前日期，具体使用方法如下：
CTime t = CTime::GetCurrentTime(); // 获取系统日期，存储在 t 里面
int d=t.GetDay(); // 获得当前日期
int y=t.GetYear(); // 获取当前年份
int m=t.GetMonth(); // 获取当前月份
int h=t.GetHour(); // 获取当前为几时
int mm=t.GetMinute(); // 获取当前分钟
int s=t.GetSecond(); // 获取当前秒
int w=t.GetDayOfWeek(); // 获取星期几，注意 1 为星期天， 7 为星期六
二 .CTimeSpan 类
如果想计算两段时间的差值，可以使用 CTimeSpan 类，具体使用方法如下：
CTime t1( 1999, 3, 19, 22, 15, 0 );
CTime t = CTime::GetCurrentTime();
CTimeSpan span=t-t1; // 计算当前系统时间与时间 t1 的间隔
int iDay=span.GetDays(); // 获取这段时间间隔共有多少天
int iHour=span.GetTotalHours(); // 获取总共有多少小时
int iMin=span.GetTotalMinutes();// 获取总共有多少分钟
int iSec=span.GetTotalSeconds();// 获取总共有多少秒
------------------------------------------------------------------------------
三 ._timeb() 函数
_timeb 定义在 SYS/TIMEB.H ，有四个 fields
dstflag
millitm
time
timezone
void _ftime( struct _timeb *timeptr );
struct _timeb timebuffer;
_ftime( &timebuffer );
取当前时间 : 文档讲可以到 ms, 有人测试 , 好象只能到 16ms!
四 . 设置计时器
定义 TIMER ID
#define TIMERID_JISUANFANGSHI 2
在适当的地方设置时钟 , 需要开始其作用的地方 ;
SetTimer(TIMERID_JISUANFANGSHI,200,NULL);
在不需要定时器的时候的时候销毁掉时钟
KillTimer(TIMERID_JISUANFANGSHI);
对应 VC 程序的消息映射
void CJisuan::OnTimer(UINT nIDEvent)
{switch(nIDEvent)}
---------------------------------------------------------------------------------------
## 如何设定当前系统时间 ---------------------------------------windows
SYSTEMTIME m_myLocalTime,*lpSystemTime;
m_myLocalTime.wYear=2003;
m_myLocalTime.wM;
m_myLocalTime.wDay=1;
m_myLocalTime.wHour=0;
m_myLocalTime.wMinute=0;
m_myLocalTime.wSec;
m_myLocalTime.wMillisec;
lpSystemTime=&m_myLocalTime;
if( SetLocalTime(lpSystemTime) ) // 此处换成 SetSystemTime( ) 也不行
MessageBox("OK !");
else
MessageBox("Error !");
SYSTEMTIME m_myLocalTime,*lpSystemTime;
m_myLocalTime.wYear=2003;
m_myLocalTime.wM;
m_myLocalTime.wDay=1;
lpSystemTime=&m_myLocalTime;
if( SetDate(lpSystemTime) ) // 此处换成 SetSystemTime( ) 也不行
MessageBox("OK !");
else
MessageBox("Error !");
本文来自 CSDN 博客，转载请标明出处： C语言获取系统时间_khuang2008的博客-CSDN博客_c语言系统时间
获取时间打印日期
time 函数
time(&rawtime) 函数获取当前时间距 1970 年 1 月 1 日的秒数，以秒计数单位，存于 rawtime 中。time ( &rawtime ); -- 获取时间，以秒计，从 1970 年 1 月一日起算，存于 rawtime
localtime ( &rawtime ); -- 转为当地时间， tm 时间结构
asctime （） -- 转为标准 ASCII 时间格式：
char *tp=asctime （）；
星期 月 日 时：分：秒 年 0x2270 "Sat Mar 17 12:08:26 2012
#include "time.h"
void main ()
{
time_t rawtime;
struct tm * timeinfo;
time ( &rawtime );
timeinfo = localtime ( &rawtime );
printf ( "/007The current date/time is: %s", asctime (timeinfo) );
exit(0);
}休眠
1.精确到微秒
#include <time.h>
#include <stdio.h>
#include <iostream>
#include <unistd.h>
using namespace std;
int main(int argc, char *argv[]){
int sleep_time = 100;
sleep(sleep_time); //休眠秒
usleep(sleep_time); //休眠微秒
}
C++11 chrono
#include <iostream>
#include <thread>
#include <chrono>
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
for (int i = 0; i < 100; i++){
cout << i << " ";
this_thread::sleep_for(chrono::seconds(5));//sleep 5秒
this_thread::sleep_for(chrono::hours(1));//sleep 1小时
this_thread::sleep_for(chrono::minutes(1));//sleep 1分钟
this_thread::sleep_for(chrono::milliseconds(1));//sleep 1毫秒
}
system("pause");
return 0;
}
linux sleep要注意的问题
printf默认是输出到标准输出，而标准输出默认使用的是行缓冲。
在sleep之前fflush(stdout)强制刷缓冲，或者在程序开始使用setbuf(stdout, NULL)禁用缓冲
当然，假如你有足够的耐心，大约过几个小时后，缓冲区终于满了，你会看到效果的。
获取日期
C语言中读取系统时间的函数为time()，其函数原型为：
#include <time.h>
time_t time( time_t * ) ;
time_t就是long，函数返回从1970年1月1日（MFC是1899年12月31日）0时0分0秒，到现在的的秒数。
可以调用ctime()函数进行时间转换输出：char * ctime(const time_t *timer);
将日历时间转换成本地时间，按年月日格式，进行输出，如：Wed Sep 23 08:43:03 2015C语言还提供了将秒数转换成相应的时间结构的函数：
struct tm * gmtime(const time_t *timer); //将日历时间转化为世界标准时间（即格林尼治时间）
struct tm * localtime(const time_t * timer); //将日历时间转为本地时间将通过time()函数返回的值，转成时间结构structtm :
struct tm {int tm_sec; /* 秒 – 取值区间为[0,59] */
int tm_min; /* 分 - 取值区间为[0,59] */
int tm_hour; /* 时 - 取值区间为[0,23] */
int tm_mday; /* 一个月中的日期 - 取值区间为[1,31] */
int tm_mon; /* 月份（从一月开始，0代表一月） - 取值区间为[0,11] */
int tm_year; /* 年份，其值等于实际年份减去1900 */
int tm_wday; /* 星期 – 取值区间为[0,6]，其中0代表星期天，1代表星期一，以此类推 */
int tm_yday; /* 从每年的1月1日开始的天数 – 取值区间为[0,365]，其中0代表1月1日，1代表1月2日，以此类推 */
int tm_isdst; /* 夏令时标识符，实行夏令时的时候，tm_isdst为正。不实行夏令时的进候，tm_isdst为0；不了解情况时，tm_isdst()为负。*/};
编程者可以根据程序功能的情况，灵活的进行日期的读取与输出了。
下面给出一段简单的代码：
#include<time.h>
int main()
{
time_t timep;
struct tm *p;
time (&timep);
p=gmtime(&timep);
printf("%d\n",p->tm_sec); /*获取当前秒*/
printf("%d\n",p->tm_min); /*获取当前分*/
printf("%d\n",8+p->tm_hour);/*获取当前时,这里获取西方的时间,刚好相差八个小时*/
printf("%d\n",p->tm_mday);/*获取当前月份日数,范围是1-31*/
printf("%d\n",1+p->tm_mon);/*获取当前月份,范围是0-11,所以要加1*/
printf("%d\n",1900+p->tm_year);/*获取当前年份,从1900开始，所以要加1900*/
printf("%d\n",p->tm_yday); /*从今年1月1日算起至今的天数，范围为0-365*/
}
原文：C语言获取当前的日期及时间_Coder802的博客-CSDN博客_c语言获取时间
linux C 中sleep “卡住”的问题
linux环境下C语言中sleep的问题
printf默认是输出到标准输出，而标准输出默认使用的是行缓冲。
在sleep之前fflush(stdout)强制刷缓冲，或者在程序开始使用setbuf(stdout, NULL)禁用缓冲
当然，假如你有足够的耐心，大约过几个小时后，缓冲区终于满了，你会看到效果的。
————————————————
原文链接：https://blog.csdn.net/sidely/article/details/40402511
Linux下的延迟函数sleep()
置顶 nigulasi_dawei 2017-06-05 11:22:37 54570 收藏 23
文章标签： 函数 linux c语言
版权
Linux下c语言中的延迟函数sleep（）的用法
#include <stdio.h>
#include <unistd.h>
int main()
{
printf("hello\n");sleep(1); //延迟1秒
printf("world\n");
return 0;
}
windows下 sleep（1000） 代表延迟1秒，因为sleep的参数为毫秒，
而在Linux下 sleep的参数为秒，所以延迟1秒为 sleep（1）。
#include <stdio.h>
#include <unistd.h>
int main()
{
printf("hello"); /*去掉转义字符'\n'*/sleep(1);
printf("world\n");
return 0;
}
1秒后
当我们去掉转义字符‘\n’,不再执行任何转义操作后，延迟函数sleep不再在语句间延迟，而是变成延迟整个程序。
借此我们来认识一下printf函数：
printf是一个行缓冲函数，先写到缓冲区，满足条件后，才将缓冲区刷到对应文件中，刷缓冲区的条件如下：
1 缓冲区填满。
2 写入的字符中有‘\n’ , ‘\r’。
3 调用fflush手动刷新缓冲区。
4 调用scanf要从缓冲区中读取数据时，也会将缓冲区内的数据刷新。
这里我们通过fflush()函数刷新缓存
include <stdio.h>
#include <unistd.h>
int main()
{
printf("hello");
fflush(stdout); //强制刷新缓存，输出显示sleep(1);
printf("world\n");
return 0;
}
原文链接：https://blog.csdn.net/nigulasi_dawei/article/details/72865390
C++时间问题（其中有一些bug） 【转】
2009-10-05 16:20:32| 分类： c++ | 标签： |字号大中小 订阅
本文从介绍基础概念入手，探讨了在C/C++中对日期和时间操作所用到的数据结构和函数，并对计时、时间的获取、时间的计算和显示格式等方面进行了阐述。本文还通过大量的实例向你展示了time.h头文件中声明的各种函数和数据结构的详细使用方法。
关键字：UTC（世界标准时间），Calendar Time（日历时间），epoch（时间点），clock tick（时钟计时单元）
1．概念
在C/C++中，对字符串的操作有很多值得注意的问题，同样，C/C++对时间的操作也有许多值得大家注意的地方。最近，在技术群中有很多网友也多次问到过C++语言中对时间的操作、获取和显示等等的问题。下面，在这篇文章中，笔者将主要介绍在C/C++中时间和日期的使用方法.
通过学习许多C/C++库，你可以有很多操作、使用时间的方法。但在这之前你需要了解一些“时间”和“日期”的概念，主要有以下几个：
Coordinated Universal Time（UTC）：协调世界时，又称为世界标准时间，也就是大家所熟知的格林威治标准时间（Greenwich Mean Time，GMT）。比如，中国内地的时间与UTC的时差为+8，也就是UTC+8。美国是UTC-5。
Calendar Time：日历时间，是用“从一个标准时间点到此时的时间经过的秒数”来表示的时间。这个标准时间点对不同的编译器来说会有所不同，但对一个编译系统来说，这个标准时间点是不变的，该编译系统中的时间对应的日历时间都通过该标准时间点来衡量，所以可以说日历时间是“相对时间”，但是无论你在哪一个时区，在同一时刻对同一个标准时间点来说，日历时间都是一样的。
epoch：时间点。时间点在标准C/C++中是一个整数，它用此时的时间和标准时间点相差的秒数（即日历时间）来表示。
clock tick：时钟计时单元（而不把它叫做时钟滴答次数），一个时钟计时单元的时间长短是由CPU控制的。一个clock tick不是CPU的一个时钟周期，而是C/C++的一个基本计时单位。
我们可以使用ANSI标准库中的time.h头文件。这个头文件中定义的时间和日期所使用的方法，无论是在结构定义，还是命名，都具有明显的C语言风格。下面，我将说明在C/C++中怎样使用日期的时间功能。
2． 计时
C/C++中的计时函数是clock()，而与其相关的数据类型是clock_t。在MSDN中，查得对clock函数定义如下：
clock_t clock( void );
这个函数返回从“开启这个程序进程”到“程序中调用clock()函数”时之间的CPU时钟计时单元（clock tick）数，在MSDN中称之为挂钟时间（wall-clock）。其中clock_t是用来保存时间的数据类型，在time.h文件中，我们可以找到对它的定义：
#ifndef _CLOCK_T_DEFINED
typedef long clock_t;
#define _CLOCK_T_DEFINED
#endif
很明显，clock_t是一个长整形数。在time.h文件中，还定义了一个常量CLOCKS_PER_SEC，它用来表示一秒钟会有多少个时钟计时单元，其定义如下：
#define CLOCKS_PER_SEC ((clock_t)1000)
可以看到可以看到每过千分之一秒（1毫秒），调用clock（）函数返回的值就加1。下面举个例子，你可以使用公式clock()/CLOCKS_PER_SEC来计算一个进程自身的运行时间：
void elapsed_time()
{
printf("Elapsed time:%u secs.\n",clock()/CLOCKS_PER_SEC);
}
当然，你也可以用clock函数来计算你的机器运行一个循环或者处理其它事件到底花了多少时间：
＃i nclude “stdio.h”
＃i nclude “stdlib.h”
＃i nclude “time.h”
int main( void )
{
long i = 10000000L;
clock_t start, finish;
double duration;
printf( "Time to do %ld empty loops is ", i );
start = clock();
while( i-- ) ;
finish = clock();
duration = (double)(finish - start) / CLOCKS_PER_SEC;
printf( "%f seconds\n", duration );
system("pause");
}
在笔者的机器上，运行结果如下：
Time to do 10000000 empty loops is 0.03000 seconds
上面我们看到时钟计时单元的长度为1毫秒，那么计时的精度也为1毫秒，那么我们可不可以通过改变CLOCKS_PER_SEC的定义，通过把它定义的大一些，从而使计时精度更高呢？通过尝试，你会发现这样是不行的。在标准C/C++中，最小的计时单位是一毫秒。
3．与日期和时间相关的数据结构
在标准C/C++中，我们可通过tm结构来获得日期和时间，tm结构在time.h中的定义如下：
#ifndef _TM_DEFINED
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;
};
#define _TM_DEFINED
#endif
ANSI C标准称使用tm结构的这种时间表示为分解时间(broken-down time)。
而日历时间（Calendar Time）是通过time_t数据类型来表示的，用time_t表示的时间（日历时间）是从一个时间点（例如：1970年1月1日0时0分0秒）到此时的秒数。在time.h中，我们也可以看到time_t是一个长整型数：
#ifndef _TIME_T_DEFINED
typedef long time_t;
#define _TIME_T_DEFINED
#endif
大家可能会产生疑问：既然time_t实际上是长整型，到未来的某一天，从一个时间点（一般是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秒到该时间点所经过的秒数。
4．与日期和时间相关的函数及应用
在本节，我将向大家展示怎样利用time.h中声明的函数对时间进行操作。这些操作包括取当前时间、算时间间隔、以不同的形式显示时间等内容。
4.1 获得日历时间
我们可以通过time()函数来获得日历时间（Calendar Time），其原型为：
time_t time(time_t * timer);
如果你已经声明了参数timer，你可以从参数timer返回现在的日历时间，同时也可以通过返回值返回现在的日历时间，即从一个时间点（例如：1970年1月1日0时0分0秒）到现在此时的秒数。如果参数为空（NULL），函数将只通过返回值返回现在的日历时间，比如下面这个例子用来显示当前的日历时间：
＃i nclude "time.h"
＃i nclude "stdio.h"
int main(void)
{
struct tm *ptr;
time_t lt;
lt =time(NULL);
printf("The Calendar Time now is %d\n",lt);
return 0;
}
运行的结果与当时的时间有关，我当时运行的结果是：
The Calendar Time now is 1122707619
其中1122707619就是我运行程序时的日历时间。即从1970年1月1日0时0分0秒到此时的秒数。
4.2 获得日期和时间
这里说的日期和时间就是我们平时所说的年、月、日、时、分、秒等信息。从第2节我们已经知道这些信息都保存在一个名为tm的结构体中，那么如何将一个日历时间保存为一个tm结构的对象呢？
其中可以使用的函数是gmtime()和localtime()，这两个函数的原型为：
struct tm * gmtime(const time_t *timer);
Sleep和 SleepEx函数
Sleep和 SleepEx函数的功能是在指定的执行时间内中止所在线程的执行。
SleepEx扩展了Sleep的功能，在最短超时时间间隔已到的情况下恢复线程执行外，在以下两种情况下发生时也可以恢复执行：I/O完成回调函数被调用、异步过程调用（APC）被安排进入线程中。
Sleep函数原型：
VOID WINAPI Sleep(
DWORD dwMillseconds);
dwMilliseconds: 指定线程挂起最短时间间隔，以ms为单位。 如设为常数INFINITE，表示将一个线程永久性的催眠
返回值：无。
SleepEx函数原型：
DWORD WINAPI SleepEx(
DWORD dwMillesconds,
BOOL bAlertable);
参数：
dwMilliseconds: 指定线程挂起最短时间间隔，以ms为单位，时间一到不管后面参数如何都会返回，如设为常数INFINITE，表示将一个线程永久性的催眠
bAlertable: 设置为FALSE，那么，在线程挂起期间不会响应。即使一个I/O完成回调函数被调用或有新的APC排进入，他们使函数返回，也不会被执行。//若是 True, 只要有 APC 函数申请, SleepEx 不管第一个参数如何都会把 APC 推入队列并随 APC 函数一起返回.//注意: SetWaitableTimer 和 SleepEx 必须在同一个线程才可以.
如用一个ReadFileEx 或 WriteFileEx函数调用初始化了一个异步I/O传输，而且我们希望函数返回，以便由那些函数指定的I/O结束例程能正常执行，就设为TRUE。
返回值：
Long。返回0表示时间间隔完成，返回WAIT_IO_COMPLETION表示I/O完成回调函数被调用。
APC是内核的一种软中断性质的东西，后面那个参数应该是这个意思，如果是false,就算有APC被插入，也要等到等待的时间到了，SleepEX才退出，如果是false,那只要有新的APC被插入了，SleepEx就马上返回了。 其实Windows的内核中Sleep就简单地理解就是线程挂在那里多少时间，不对这个线程调度。CPU的时间片都分配到其他线程中，除非等待时间到了，再继续调度和分配时间片。APC就相当于一个额外的调度。
像谷歌的这段，我也搜索看过
如设为常数INFINITE，表示将一个线程永久性的催眠 UpK软件安全社区3 a2 B: g3 Q/ U2 h7 v' y8 Q) u: Q8 d0 J3 B7 j9 D4 K
bAlertable Long，如用一个ReadFileEx 或 WriteFileEx函数调用初始化了一个异步I/O传输，而且我们希望函数返回，以便由那些函数指定的I/O结束例程能正常执行，就设为TRUE$ K6 t; _- A% l6 v% b
是什么意思？当参设为无限时间的时候，调用ReadFileEx后就返回？
不是这个意思，对线程的APC操作一般都是ring0里面搞的，ring3下也可以搞，不过绝对不是你理解的ReadFile什么的函数。+ [' u. N+ k# O \0 `% A
比如这么说把，搞一个dll的注入，可以用两种方式，一种是用CreateRemoteThread函数(CreateRemoteThread 最后在ring0是否还是调用了插入APC,我没有去了解)，另外一种就是直接插入一个APC。
/ n6 M; }# K/ q5 }# p9 u
假设你的线程一直在SleepEx(-1,false),如果这个时候有人想用APC在你的线程里增加一个新的调度，那这个调度是不会被执行的，因为线程在内核里标记为挂起，如果你用SleepEx(-1,True)，那会被马上调度这个Apc而且SleepEx函数返回。
