Win32时间类型FILETIME/SYSTEMTIME/WINDOWSTIME（FILETIME这个名字很奇怪，其实他跟FILE并没有直接关系，只是很多File的API中，都以这个为时间的类型）

最新推荐文章于 2022-03-25 11:57:25 发布

haiross

最新推荐文章于 2022-03-25 11:57:25 发布

阅读量2.3k

点赞数 1

分类专栏： C++开发

C++开发专栏收录该内容

294 篇文章 11 订阅

订阅专栏

Win32的时间类型

在Win32时间类型有这样几种类型 FILETIME/

SYSTEMTIME/WINDOWSTIME
 
 先提个问题，如何计算当前时间100天以后的时间，在win32中。
 
 1.SYSTEMTIME

SYSTEMTIME的定义是这样

typedef struct   _SYSTEMTIME
    {
    WORD wYear;
    WORD wMonth;
    WORD wDayOfWeek;
    WORD wDay;
    WORD wHour;
    WORD wMinute;
    WORD wSecond;
    WORD wMilliseconds;
    } SYSTEMTIME;

很大，总共16个字节。你可以调用GetSystemTime来取得当前的时间

SYSTEMTIME st;
::GetSystemTime( & st);

但是如果你调用 st.wDay += 100;是达不到效果的，将会得到一个无效的时间格式

2. FILETIME
FILETIME的定义是这样的

typedef struct   _FILETIME
    {
    DWORD dwLowDateTime;
    DWORD dwHighDateTime;
    } FILETIME;

FILETIME这个名字很奇怪，其实他跟FILE并没有直接关系，只是很多File的API中，都以这个为时间的类型，比如你可以调用GetFileTime来取得File的创建/修改/访问时间。
FILETIME是一个__int64。可以这样转化成__int64

__int64 d = * (__int64 * ) & st;

// or

__int64 d2;
memcpy( & d2, & st, sizeof (d2));

转化为__int64是一个以100纳秒为单位的值
补习一下时间单位( http://blog.vckbase.com/zaboli/archive/2005/06/29/8969.aspx)

1ms (毫秒)	1毫秒=0.001秒=10-3秒(millisecond)
1μs (微秒)	1微秒=0.000001=10-6秒(microsecond)
1ns (纳秒)	1纳秒=0.000000001秒=10-9秒（nanosecond)
1ps (皮秒)	1皮秒=0.000000000001秒=10-12秒
1fs (飞秒)	1飞秒=0.00000000000001秒=10-15秒

SYSTEMTIME可以通过SystemTimeToFileTime来转化为FILETIME

3.Window Time
::GetTickCount()可以返回当前的以微秒为单位的时间，用在精度要求不高的场合，返回的只是一个DWORD，四字节。高一点的使用timeGetTime

如何计算当前时间100天以后的时间，在win32中。
应该这样写

const __int64 nano100SecInDay = (__int64) 10000000 * 60 * 60 * 24 ;

SYSTEMTIME st;
::GetSystemTime( & st);
FILETIME f;
::SystemTimeToFileTime( & st, & f);
ULARGE_INTEGER now;
memcpy( & now, & f, sizeof (now));
now += 100 * nano100SecInDay;
memcpy( & f, & now, sizeof (f));
FileTimeToSystemTime( & f, & st);

最后：附上我写的一个小工具，删除指定文件夹下面的过期文件的一个工具，并可以备份，支持子文件夹嵌套。

#include < windows.h >
#include < cstdio >
#include < string >
using namespace std;

const __int64 nano100SecInDay = (__int64) 10000000 * 60 * 60 * 24 ;
ULARGE_INTEGER now;
int days = 14 ;
bool backup = false ;
string dst_dir;
string backup_dir;

void make_sure_dir_exist( string & file)
{
     int tag = 2 ;
     while ( true )
    {
        tag = file.find_first_of( " \\ " ,tag + 1 );
         if (tag !=- 1 )
        {
             string tmp = file.substr( 0 ,tag);
            ::CreateDirectory(tmp.c_str(),NULL);
        }
         else
        {
             break ;
        }
    }
}

void xdel( const char * dir)
{
     char tempFileFind[ 1024 ];
    sprintf(tempFileFind, " %s\\*.* " ,dir);

    WIN32_FIND_DATA ffd;
    HANDLE hFind;
    hFind = ::FindFirstFile(tempFileFind, & ffd);

     if (hFind == INVALID_HANDLE_VALUE)
    {
        printf( " can't find %s\n " ,dir);
         return ;
    }

     while ( true )
    {
         // printf("find %s\n",ffd.cFileName);
        FILETIME & ft = ffd.ftLastWriteTime;
        ULARGE_INTEGER ui;
        memcpy( & ui, & ft, sizeof (ui));
        __int64 t = now.QuadPart - ui.QuadPart;

         if (ffd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
        {
             if (strcmp(ffd.cFileName, " . " ) && strcmp(ffd.cFileName, " .. " ))
            {
                 char temp[ 1024 ];
                sprintf(temp, " %s\\%s " ,dir,ffd.cFileName);
                xdel(temp);

                 if (t >= nano100SecInDay * days)
                {
                     if (::RemoveDirectory(temp))
                    {
                        printf( " del dir %s ok\n " ,temp);
                    }
                     else
                    {
                        printf( " del dir %s failed\n " ,temp);
                    }
                }
            }
        }
         else
        {
             char temp[ 1024 ];
            sprintf(temp, " %s\\%s " ,dir,ffd.cFileName);

             if (t >= nano100SecInDay * days)
            {
                 if (backup)
                {
                     string backup_file = temp;
                    backup_file.replace( 0 ,dst_dir.length(),backup_dir.c_str());
                    make_sure_dir_exist(backup_file);
                     if (::MoveFile(temp,backup_file.c_str()))
                    {
                        printf( " backup file %s ok\n " ,temp);
                    }
                     else
                    {
                        printf( " backup file %s failed\n " ,temp);
                    }
                }
                 else
                {
                    SetFileAttributes(temp,FILE_ATTRIBUTE_NORMAL);
                     if (::DeleteFile(temp))
                    {
                        printf( " del file %s ok\n " ,temp);
                    }
                     else
                    {
                        printf( " del file %s failed\n " ,temp);
                    }
                }
            }
        }
         if ( ! FindNextFile(hFind, & ffd))
        {
             break ;
        }
    }
    FindClose(hFind);
}

int main( int argc, char ** argv)
{
     if (argc < 2 )
    {
        printf( " usage: xdel directory /d= /m=\n " );
        printf( " [optional] /d: config the expired days,default is 14 days\n " );
        printf( " [optional] /m: config the backup directory\n " );
        printf( " for example: xdel d:\\test /d=10 /m=d:\\backup " );
         return 1 ;
    }

     for ( int i = 1 ;i < argc; ++ i)
    {
         string tmp = argv[i];
         if (tmp.find( " /d= " ) !=- 1 )
        {
             int d = atoi(tmp.substr( 3 ).c_str());
             if (d != 0 )
            {
                days = d;
            }
        }
         else if (tmp.find( " /m= " ) !=- 1 )
        {
            backup = true ;
            backup_dir = tmp.substr( 3 );
        }
         else
        {
            dst_dir = tmp;
        }
    }

     // Get system time
    SYSTEMTIME st;
    ::GetSystemTime( & st);
    FILETIME f;
    ::SystemTimeToFileTime( & st, & f);
    memcpy( & now, & f, sizeof (now));

    xdel(argv[ 1 ]);

     return 0 ;
}