原文： http://zetcode.com/gui/winapi/datetime/

在 Windows API 教程的这一部分中，我们将使用日期和时间。 ZetCode 的文章处理 ANSI C 中的日期和时间。

SYSTEMTIME结构用于 Windows API 中的日期和时间。 时间可以是协调世界时（UTC）或本地时间。 它具有以下成员：

  1. WORD wYear;
  2. WORD wMonth;
  3. WORD wDayOfWeek;
  4. WORD wDay;
  5. WORD wHour;
  6. WORD wMinute;
  7. WORD wSecond;
  8. WORD wMilliseconds;

SYSTEMTIME结构用GetSystemTime()函数或GetLocalTime()函数填充。 然后，我们可以访问结构的成员以获取当前日期或时间。

FILETIME结构包含一个 64 位的值，该值表示自 1601 年 1 月 1 日（UTC）起 100 纳秒间隔的数量。 使用此值，我们可以计算 Windows API 纪元或日期时间差。

  1. DWORD dwLowDateTime;
  2. DWORD dwHighDateTime;

FILETIME结构具有两个成员：dwLowDateTime是文件时间的低阶部分，dwHighDateTime是文件时间的高阶部分。 为了从两个成员中获得单个值，我们利用了LARGE_INTEGER并集。

FileTimeToSystemTime()和SystemTimeToFileTime()函数用于在两个结构之间进行转换。

当地时间

本地时间定义为用户所在时区中的当前时间。

localtime.c

  1. #include <windows.h>
  2. #include <wchar.h>
  4. int wmain(void) {
  6.     SYSTEMTIME lt = {0};
  8.     GetLocalTime(&lt);
  10.     wprintf(L"The local time is: %02d:%02d:%02d\n", 
  11.         lt.wHour, lt.wMinute, lt.wSecond);
  13.     return 0;
  14. }

程序将打印本地时间。

  1. SYSTEMTIME lt = {0};

我们声明SYSTEMTIME结构。 通过调用特定的时间函数来填充此结构的成员。

  1. GetLocalTime(&lt);

GetLocalTime()检索当前的本地日期和时间。 它用当前日期&时间值填充SYSTEMTIME结构的成员。

  1. wprintf(L"The local time is: %02d:%02d:%02d\n", 
  2.   lt.wHour, lt.wMinute, lt.wSecond);

我们以hh:mm:ss格式打印当前本地时间。

  1. C:\Users\Jano\Documents\Pelles C Projects\timedate\LocalTime>LocalTime.exe
  2. The local time is: 20:20:07

这是示例输出。

UTC 时间

我们的星球是一个球体。 它绕其轴旋转。 地球向东旋转。 因此，太阳在不同位置的不同时间升起。 地球大约每 24 小时旋转一次。 因此，世界被划分为 24 个时区。 在每个时区，都有一个不同的本地时间。 夏令时通常会进一步修改此本地时间。

实际需要一个全球时间。 全球时间可以避免时区和夏令时的混淆。 UTC（世界标准时间）被选为主要时间标准。 UTC 用于航空，天气预报，飞行计划，空中交通管制通关和地图。 与当地时间不同，UTC 不会随季节变化而变化。

Windows API 具有GetSystemTime()函数以获取 UTC 时间。

utctime.c

  1. #include <windows.h>
  2. #include <wchar.h>
  4. int wmain(void) {
  6.     SYSTEMTIME st = {0};
  8.     GetSystemTime(&st);
  10.     wprintf(L"The UTC time is: %02d:%02d:%02d\n", 
  11.         st.wHour, st.wMinute, st.wSecond);
  13.     return 0;
  14. }

在示例中，我们计算 UTC 时间。

  1. SYSTEMTIME st = {0};

UTC 时间将存储在SYSTEMTIME结构中。

  1. GetSystemTime(&st);

我们使用GetSystemTime()函数检索 UTC 时间。

  1. wprintf(L"The UTC time is: %02d:%02d:%02d\n", 
  2.   st.wHour, st.wMinute, st.wSecond);

UTC 时间以hh:mm:ss格式打印到控制台。

  1. C:\Users\Jano\Documents\Pelles C Projects\timedate\UtcTime>UtcTime.exe
  2. The UTC time is: 19:25:20

这是 UTC 时间的输出。

算术

不建议对SYSTEMTIME结构中的值进行算术运算以获得相对时间。 相反，我们将SYSTEMTIME结构转换为FILETIME结构，将所得的FILETIME结构复制到ULARGE_INTEGER结构，并对ULARGE_INTEGER值使用常规的 64 位算术。 最后，我们将FILETIME结构转换回SYSTEMTIME结构。

arithmetic.c

  1. #include <windows.h>
  2. #include <wchar.h>
  4. #define NSECS 60*60*3
  6. int wmain(void) {
  8.     SYSTEMTIME st = {0};
  9.     FILETIME ft = {0};
  11.     GetLocalTime(&st);
  13.     wprintf(L"%02d/%02d/%04d %02d:%02d:%02d\n",
  14.         st.wDay, st.wMonth, st.wYear, st.wHour, st.wMinute, st.wSecond);
  16.     SystemTimeToFileTime(&st, &ft);
  18.     ULARGE_INTEGER u = {0};
  20.     memcpy(&u, &ft, sizeof(u));
  21.     u.QuadPart += NSECS * 10000000LLU;
  22.     memcpy(&ft, &u, sizeof(ft));
  24.     FileTimeToSystemTime(&ft, &st);
  26.     wprintf(L"%02d/%02d/%04d %02d:%02d:%02d\n",
  27.         st.wDay, st.wMonth, st.wYear, st.wHour, st.wMinute, st.wSecond);
  29.     return 0;
  30. }

在示例中，我们将三个小时添加到当前本地时间值。

  1. #define NSECS 60*60*3

三个小时以秒表示。

  1. GetLocalTime(&st);

使用GetLocalTime()函数，我们可以获取当前本地时间。

  1. SystemTimeToFileTime(&st, &ft);

我们调用SystemTimeToFileTime()函数将SYSTEMTIME结构转换为FILETIME结构。

  1. ULARGE_INTEGER u = {0};

ULARGE_INTEGER结构已创建。

  1. memcpy(&u, &ft, sizeof(u));
  2. u.QuadPart += NSECS * 10000000LLU;
  3. memcpy(&ft, &u, sizeof(ft));

我们向ULARGE_INTEGER结构的QuadPart成员添加了三个小时。 成员以 100 纳秒刻度表示； 因此，我们将NSECS乘以10000000LLU。

  1. FileTimeToSystemTime(&ft, &st);

我们将FILETIME结构转换回SYSTEMTIME结构。

  1. C:\Users\Jano\Documents\Pelles C Projects\timedate\Arithmetic>Arithmetic.exe
  2. 01/02/2016 13:28:13
  3. 01/02/2016 16:28:13

这是Arithmetic.exe的示例输出。 已将三个小时正确地添加到当前本地时间。

日期

GetLocalTime()函数还用于确定当前日期。

today.c

  1. #include <windows.h>
  2. #include <wchar.h>
  4. int wmain(void) {
  6.     SYSTEMTIME st = {0};
  8.     GetLocalTime(&st);
  10.     wprintf(L"Today is: %d-%02d-%02d\n", st.wYear, st.wMonth, st.wDay);
  12.     return 0;
  13. }

上面的程序打印今天的日期。

  1. SYSTEMTIME st = {0};

我们声明一个SYSTEMTIME结构。

  1. GetLocalTime(&st);

我们用当前的本地时间和日期值填充SYSTEMTIME成员。

  1. wprintf(L"Today is: %d-%02d-%02d\n", st.wYear, st.wMonth, st.wDay);

当前日期将打印到控制台。 我们选择了公历大端日期格式。

  1. C:\Users\Jano\Documents\Pelles C Projects\timedate\Today>Today.exe
  2. Today is: 2016-01-30

这是Today.exe程序的输出。

格式化日期

GetDateFormatEx()函数将日期格式化为指定语言环境的日期字符串。

date_format.c

  1. #include <windows.h>
  2. #include <wchar.h>
  4. int wmain(void) {
  6.     PDWORD cChars = NULL;
  7.     HANDLE std = GetStdHandle(STD_OUTPUT_HANDLE);   
  9.     if (std == INVALID_HANDLE_VALUE) {
  10.         wprintf(L"Cannot retrieve standard output handle %d\n", 
  11.             GetLastError());
  12.         return 1;
  13.     }
  15.     SYSTEMTIME lt = {0};
  16.     GetLocalTime(&lt);
  18.     wchar_t buf[128] = {0};
  20.     int r = GetDateFormatEx(LOCALE_NAME_USER_DEFAULT, DATE_LONGDATE, 
  21.                 &lt, NULL, buf, sizeof(buf)/sizeof(buf[0]), NULL);
  23.     if (r == 0) {
  25.         wprintf(L"GetDateFormatEx function failed %d\n", 
  26.             GetLastError());
  28.         CloseHandle(std);
  30.         return 1;
  31.     }
  33.     WriteConsoleW(std, buf, wcslen(buf), cChars, NULL);
  35.     r = CloseHandle(std);
  37.     if (r == 0) {
  39.         wprintf(L"Cannot close console handle %d\n", 
  40.             GetLastError());
  41.         return 1;    
  42.     }
  44.     CloseHandle(std);
  46.     return 0;
  47. }

程序以本地化格式打印当前本地时间。

  1. SYSTEMTIME lt = {0};
  2. GetLocalTime(&lt);

检索当地时间。

  1. int r = GetDateFormatEx(LOCALE_NAME_USER_DEFAULT, DATE_LONGDATE, 
  2.             &lt, NULL, buf, sizeof(buf)/sizeof(buf[0]), NULL);

GetDateFormatEx()以区域和语言选项中指定的默认语言环境格式化日期。 日期以长日期格式打印。

  1. WriteConsoleW(std, buf, wcslen(buf), cChars, NULL);

日期将打印到控制台。

  1. C:\Users\Jano\Documents\Pelles C Projects\timedate\DateFormat>DateFormat.exe
  2. 1\. februára 2016

程序以斯洛伐克语打印日期。

确定闰年

闰年是包含额外一天的年份。 日历中额外一天的原因是天文日历年与日历年之间的差异。 日历年正好是 365 天，而天文学年（地球绕太阳公转的时间）是 365.25 天。 相差 6 个小时，这意味着在四年的时间里，我们一天中都没有。 因为我们希望日历与季节同步，所以每四年将 2 月增加一天。 （有例外。）在公历中，February 年的 2 月有 29 天，而不是通常的 28 天。该年持续 366 天，而不是通常的 365 天。

leapyear.c

  1. #include <windows.h>
  2. #include <stdbool.h>
  3. #include <wchar.h>
  5. bool isLeapYear(int);
  7. int wmain(void) {
  9.     // Assume year >= 1582 in the Gregorian calendar.
  10.     int years[] = { 2000, 2002, 2004, 2008, 2012, 2016, 2020,
  11.         1900, 1800, 1600 };
  13.     int size = sizeof(years) / sizeof(int);
  15.     for (int i=0; i<size; i++) {
  17.         if (isLeapYear(years[i])) {
  19.             wprintf(L"%ld is a leap year\n", years[i]);
  20.         } else {
  22.             wprintf(L"%ld is not a leap year\n", years[i]);
  23.         }
  24.     }
  26.     return 0;
  27. }
  29. bool isLeapYear(int year) {
  31.     if (year % 4 != 0) {
  33.         return false;
  34.     } else if (year % 400 == 0) {
  36.         return true;
  37.     } else if (year % 100 == 0) {
  39.         return false;
  40.     } else {
  42.         return true;
  43.     }
  44. }

我们有很多年。 我们检查所有年份是否为闰年。 没有内置函数可以检查闰年。 我们创建了一个自定义的isLeapYear()函数。

  1. // Assume year >= 1582 in the Gregorian calendar.
  2. int years[] = { 2000, 2002, 2004, 2008, 2012, 2016, 2020,
  3.     1900, 1800, 1600 };

这是我们要检查的年份。 年份必须在公历中。

  1. for (int i=0; i<size; i++) {
  3.     if (isLeapYear(years[i])) {
  5.         wprintf(L"%ld is a leap year\n", years[i]);
  6.     } else {
  8.         wprintf(L"%ld is not a leap year\n", years[i]);
  9.     }
  10. }

使用 for 循环，我们遍历数组。 我们使用isLeapYear()函数检查年份是否为闰年。

  1. bool isLeapYear(int year) {
  3.     if (year % 4 != 0) {
  5.         return false;
  6.     } else if (year % 400 == 0) {
  8.         return true;
  9.     } else if (year % 100 == 0) {
  11.         return false;
  12.     } else {
  14.         return true;
  15.     }
  16. }

这是确定闰年的功能。 年是 4 的整数倍。年份是 100 的整数倍，则不是闰年，除非它也是 400 的整数倍，在这种情况下，它也是闰年。

  1. C:\Users\Jano\Documents\Pelles C Projects\timedate\LeapYear>LeapYear.exe
  2. 2000 is a leap year
  3. 2002 is not a leap year
  4. 2004 is a leap year
  5. 2008 is a leap year
  6. 2012 is a leap year
  7. 2016 is a leap year
  8. 2020 is a leap year
  9. 1900 is not a leap year
  10. 1800 is not a leap year
  11. 1600 is a leap year

LeapYear.exe程序的输出。

正常运行时间

GetTickCount()函数可用于获取计算机的正常运行时间。 它检索自系统启动以来经过的毫秒数。

  1. DWORD WINAPI GetTickCount(void);

该函数返回DWORD值，因此返回的最大天数为 49.7。 为了克服这个限制，我们可以使用GetTickCount64()。 从 Windows Vista 开始，该函数可用。

uptime.c

  1. #include <windows.h>
  2. #include <wchar.h>
  4. int wmain(void) {  
  6.     DWORD tc = GetTickCount();
  8.     short seconds = tc / 1000 % 60; 
  9.     short minutes = tc / 1000 / 60 % 60; 
  10.     short hours = tc / 1000 / 60 / 60 % 24; 
  11.     short days = tc / 1000 / 60 / 60 / 24 % 7;  
  12.     short weeks = tc / 1000 / 60 / 60 / 24 / 7 % 52; 
  14.     wprintf(L"Computer has been running for: ");
  16.     if (weeks > 0 && weeks != 1) {
  18.         wprintf(L"%hi weeks ", weeks);
  19.     } else if (weeks == 1) {
  21.         wprintf(L"1 week ");
  22.     }
  24.     if (days > 0 && days != 1) {
  26.         wprintf(L"%hi days ", days);
  27.     } else if (days == 1) {
  29.         wprintf(L"1 day ");
  30.     }
  32.     if (hours > 0 && hours != 1) {
  34.         wprintf(L"%hi hours ", hours);
  35.     } else if (hours == 1) {
  37.         wprintf(L"1 hour ");
  38.     }
  40.     if (minutes > 0 && minutes != 1) {
  42.         wprintf(L"%hi minutes ", minutes); 
  43.     } else if (minutes == 1) {
  45.         wprintf(L"1 minute ");
  46.     }
  48.     wprintf(L"and %hi seconds\n", seconds);
  50.     return 0;
  51. }

该程序将打印计算机的正常运行时间。 我们使用GetTickCount()函数。 如果计算机运行的时间少于 49.71 天或 4294967296 ms，它将正常工作。 之后，DWORD值溢出。

  1. DWORD tc = GetTickCount();

我们得到计算机正在运行的毫秒数。 DWORD变量可以存储的最大数量为ULONG_MAX。

  1. short seconds = tc / 1000 % 60; 
  2. short minutes = tc / 1000 / 60 % 60; 
  3. short hours = tc / 1000 / 60 / 60 % 24; 
  4. short days = tc / 1000 / 60 / 60 / 24 % 7;  
  5. short weeks = tc / 1000 / 60 / 60 / 24 / 7 % 52;

我们计算秒，分钟，小时，天和周。

  1. if (weeks > 0 && weeks != 1) {
  3.   wprintf(L"%hi weeks ", weeks);
  4. } else if (weeks == 1) {
  6.   wprintf(L"1 week ");
  7. }

如果计算机正在运行一个或多个星期，则可以在控制台上打印week变量或"1 week"字符串。

  1. C:\winapi\examples2\datetime\Uptime>Uptime.exe
  2. Computer has been running for: 3 hours 31 minutes and 7 seconds

样本输出。

星期几

SYSTEMTIME结构的wDayOfWeek成员存储星期几。 值是1..7，其中 1 是星期日，2 星期一，… 7 星期六。

dayofweek.c

  1. #include <windows.h>
  2. #include <wchar.h>
  4. int wmain(void) {
  6.     SYSTEMTIME st = {0};
  8.     wchar_t *dn[] = { L"Sunday", L"Monday", L"Tuesday", 
  9.         L"Wednesday", L"Thursday", L"Friday", L"Saturday" };
  11.     GetLocalTime(&st);
  12.     wprintf(L"Today is %ls\n", dn[st.wDayOfWeek]);
  14.     return 0;
  15. }

该代码将星期几显示在控制台上。

  1. wchar_t *dn[] = { L"Sunday", L"Monday", L"Tuesday", 
  2.   L"Wednesday", L"Thursday", L"Friday", L"Saturday" };

我们将日期名称存储在字符串数组中。

  1. GetLocalTime(&st);
  2. wprintf(L"Today is %ls\n", dn[st.wDayOfWeek]);

这些行检索并打印星期几。

  1. C:\Users\Jano\Documents\Pelles C Projects\timedate\DayOfWeek>DayOfWeek.exe
  2. Today is Sunday

这是输出。

纪元

纪元是选择作为特定纪元起源的时间瞬间。 例如，在西方基督教国家，时期从耶稣出生（据信出生）的第 0 天开始。 另一个例子是法国共和党日历，使用了十二年。 这个时期是 1792 年 9 月 22 日宣布的共和纪元的开始，即宣布成立第一共和国并废除君主制的那一天。 电脑也有自己的纪元。 最受欢迎的时间之一是 Unix 时间。 Unix 纪元是 1970 年 1 月 1 日 UTC 时间 00:00:00（或1970-01-01T00:00:00Z ISO8601）。 计算机中的日期和时间是根据自该计算机或平台的定义时期以来经过的秒数或时钟滴答数确定的。

Windows 操作系统有几个时期。 Microsoft Excel，MS SQL Server 或 FAT32 文件系统具有不同的时间纪元。 Windows API 纪元是 UTC 1601 年 1 月 1 日 00:00:00。 选择此日期的原因是接受公历 400 周年。 周年纪念日是在 Windows NT 设计之初。 FILETIME结构包含一个 64 位的值，该值表示自 1601 年 1 月 1 日（UTC）起 100 纳秒间隔的数量。

windows_epoch.c

  1. #include <windows.h>
  2. #include <wchar.h>
  4. int wmain(void) {
  6.     FILETIME ft = {0};
  8.     GetSystemTimeAsFileTime(&ft);
  10.     LARGE_INTEGER li = {0};    
  12.     li.LowPart = ft.dwLowDateTime;
  13.     li.HighPart = ft.dwHighDateTime;
  15.     long long int hns = li.QuadPart;
  17.     wprintf(L"%lli hundreds of nanoseconds have elapsed " 
  18.         "since Windows API epoch\n", hns);
  20.     return 0;
  21. }

该代码示例计算从 Windows API 纪元到现在为止经过的 100 纳秒间隔的数量。

  1. FILETIME ft = {0};

我们声明FILETIME结构。 它有两个成员。 dwLowDateTime保留文件时间的低位部分。 dwHighDateTime保留文件时间的高位部分。

  1. LARGE_INTEGER li = {0};

LARGE_INTEGER是一个联合，可帮助我们将FILETIME结构的成员转换为 100 纳秒的间隔。

  1. li.LowPart = ft.dwLowDateTime;
  2. li.HighPart = ft.dwHighDateTime;

FILETIME结构的值将复制到大整数联合成员。

  1. long long int hns = li.QuadPart;

QuadPart成员存储从LowPart和HighPart成员确定的数百纳秒数。 它是一个巨大的数字，存储为 64 位整数。

  1. wprintf(L"%lli hundreds of nanoseconds have elapsed " 
  2.   "since Windows API epoch\n", hns);

该值将打印到控制台。

  1. C:\Users\Jano\Documents\Pelles C Projects\timedate\WindowsEpoch>WindowsEpoch.exe
  2. 130987330019489987 hundreds of nanoseconds have elapsed since Windows API epoch

这是示例输出。

以下示例将 Windows API 时间转换为 Unix 时间。

unix_time.c

  1. #include <windows.h>
  2. #include <wchar.h>
  4. #define WINDOWS_TICKS_PER_SEC 10000000
  5. #define EPOCH_DIFFERENCE 11644473600LL
  7. long long WindowsTicksToUnixSeconds(long long);
  9. int wmain(void) {
  11.     FILETIME ft = {0};
  13.     GetSystemTimeAsFileTime(&ft);
  15.     LARGE_INTEGER li = {0};    
  17.     li.LowPart = ft.dwLowDateTime;
  18.     li.HighPart = ft.dwHighDateTime;
  20.     long long int hns = li.QuadPart;
  22.     wprintf(L"Windows API time: %lli\n", hns);
  24.     long long int utm = WindowsTicksToUnixSeconds(hns);
  26.     wprintf(L"Unix time: %lli\n", utm);
  28.     return 0;
  29. }
  31. long long int WindowsTicksToUnixSeconds(long long windowsTicks) {
  33.      return (windowsTicks / WINDOWS_TICKS_PER_SEC - EPOCH_DIFFERENCE);
  34. }

该示例显示 Windows API 时间和 Unix 控制台时间。

  1. #define EPOCH_DIFFERENCE 11644473600LL

两个时期之间的差是11644473600LL。 请注意，闰秒是 1972 年引入的，因此我们没有将它们考虑在内。

  1. long long int WindowsTicksToUnixSeconds(long long windowsTicks) {
  3.      return (windowsTicks / WINDOWS_TICKS_PER_SEC - EPOCH_DIFFERENCE);
  4. }

该函数将 Windows 刻度转换为 Unix 时间秒。

  1. C:\Users\Jano\Documents\Pelles C Projects\timedate\UnixTime>UnixTime.exe
  2. Windows API time: 130987431026414297
  3. Unix time: 1454269502

这是UnixTime.exe示例的输出。

直到 XMas 的天数

Windows API 没有任何函数来计算两天之间的差异。 我们必须自己做数学。

days_to_xmas.c

  1. #include <windows.h>
  2. #include <wchar.h>
  4. int wmain(void) {
  6.     FILETIME ft1 = {0};
  7.     FILETIME ft2 = {0};
  8.     SYSTEMTIME st = {0};  
  9.     LARGE_INTEGER li1 = {0};    
  10.     LARGE_INTEGER li2 = {0}; 
  12.     st.wYear = 2016;
  13.     st.wMonth = 12;
  14.     st.wDay = 25;
  16.     int r = SystemTimeToFileTime(&st, &ft1);
  18.     if (r == 0) {
  20.         wprintf(L"Failed to convert system time to file time\n (%d)", 
  21.             GetLastError());
  22.         return 1;
  23.     }
  25.     GetSystemTimeAsFileTime(&ft2);
  27.     li1.LowPart = ft1.dwLowDateTime;
  28.     li1.HighPart = ft1.dwHighDateTime;
  30.     li2.LowPart = ft2.dwLowDateTime;
  31.     li2.HighPart = ft2.dwHighDateTime;
  33.     long long int dif = li1.QuadPart - li2.QuadPart;
  35.     int days2xmas = dif / 10000000L / 60 / 60 / 24;
  37.     if (days2xmas == 1) {
  39.         wprintf(L"There is one day until Christmas\n", days2xmas);
  40.     } else if (days2xmas == 0) {
  42.         wprintf(L"Today is Chritmas\n");
  43.     } else {
  45.         wprintf(L"There are %d days until Christmas\n", days2xmas);
  46.     }
  48.     return 0;
  49. }

该代码示例计算直到圣诞节的天数。

  1. FILETIME ft1 = {0};
  2. FILETIME ft2 = {0};
  3. SYSTEMTIME st = {0};  
  4. LARGE_INTEGER li1 = {0};    
  5. LARGE_INTEGER li2 = {0};

我们需要FILETIME，SYSTEMTIME结构和LARGE_INTEGER并集来进行计算。

  1. st.wYear = 2016;
  2. st.wMonth = 12;
  3. st.wDay = 25;

SYSTEMTIME结构填充了圣诞节的值。

  1. int r = SystemTimeToFileTime(&st, &ft1);

圣诞节的系统时间将转换为文件时间。

  1. GetSystemTimeAsFileTime(&ft2);

我们使用GetSystemTimeAsFileTime()函数将当前日期作为文件时间。

  1. li1.LowPart = ft1.dwLowDateTime;
  2. li1.HighPart = ft1.dwHighDateTime;
  4. li2.LowPart = ft2.dwLowDateTime;
  5. li2.HighPart = ft2.dwHighDateTime;

我们用文件时间的低位和高位部分填充两个并集。

  1. long long int dif = li1.QuadPart - li2.QuadPart;

计算两个日期之间的差。

  1. int days2xmas = dif / 10000000L / 60 / 60 / 24;

差异以 100 纳秒表示。 此值转换为天。

  1. C:\Users\Jano\Documents\Pelles C Projects\timedate\DaysToXmas>DaysToXmas.exe
  2. There are 328 days until Christmas

在 2016 年 1 月 31 日，我们获得了此输出。

比较时间

CompareFileTime()函数可用于比较两个文件时间。 当指定的第一次时间较早时，该函数返回 -1。 当两次相等时，它返回 0。 当第一次晚于第二个文件时间时，它将返回 1。

compare_time.c

  1. #include <windows.h>
  2. #include <wchar.h>
  4. int wmain(void) {
  6.     SYSTEMTIME st1 = {0};
  7.     SYSTEMTIME st2 = {0};
  8.     FILETIME ft1 = {0};
  9.     FILETIME ft2 = {0};
  11.     st1.wYear = 2015;
  12.     st1.wMonth = 4;
  13.     st1.wDay = 12;
  15.     st2.wYear = 2015;
  16.     st2.wMonth = 5;
  17.     st2.wDay = 12;
  19.     int r1 = SystemTimeToFileTime(&st1, &ft1);
  21.     if (r1 == 0) {
  23.         wprintf(L"Failed to convert system time to file time\n (%d)", 
  24.             GetLastError());
  25.         return 1;
  26.     }
  28.     int r2 = SystemTimeToFileTime(&st2, &ft2);
  30.     if (r2 == 0) {
  32.         wprintf(L"Failed to convert system time to file time\n (%d)", 
  33.             GetLastError());
  34.         return 1;
  35.     }
  37.     short ct = CompareFileTime(&ft1, &ft2);
  39.     if (ct == -1) {
  41.         wprintf(L"4/12/2015 comes before 5/12/2015\n");
  42.     } else if (ct == 0) {
  44.         wprintf(L"4/12/2015 is equal to 5/12/2015\n");
  45.     } else if (ct == 1) {
  47.         wprintf(L"4/12/2015 comes after 5/12/2015\n");
  48.     }
  50.     return 0;
  51. }

我们有两个时间值。 我们使用CompareFileTime()来确定哪个时间更早。

  1. st1.wYear = 2015;
  2. st1.wMonth = 4;
  3. st1.wDay = 12;
  5. st2.wYear = 2015;
  6. st2.wMonth = 5;
  7. st2.wDay = 12;

两次定义。

  1. int r1 = SystemTimeToFileTime(&st1, &ft1);
  3. if (r1 == 0) {
  5.     wprintf(L"Failed to convert system time to file time\n (%d)", 
  6.         GetLastError());
  7.     return 1;
  8. }
  10. int r2 = SystemTimeToFileTime(&st2, &ft2);
  12. if (r2 == 0) {
  14.     wprintf(L"Failed to convert system time to file time\n (%d)", 
  15.         GetLastError());
  16.     return 1;
  17. }

使用SystemTimeToFileTime()函数调用将系统时间转换为文件时间。

  1. short ct = CompareFileTime(&ft1, &ft2);

将两个文件时间与CompareFileTime()函数进行比较。

  1. if (ct == -1) {
  3.     wprintf(L"4/12/2015 comes before 5/12/2015\n");
  4. } else if (ct == 0) {
  6.     wprintf(L"4/12/2015 is equal to 5/12/2015\n");
  7. } else if (ct == 1) {
  9.     wprintf(L"4/12/2015 comes after 5/12/2015\n");
  10. }

根据返回的值，我们将消息打印到控制台。

  1. C:\Users\Jano\Documents\Pelles C Projects\timedate\CompareTime>CompareTime.exe
  2. 4/12/2015 comes before 5/12/2015

这是CompareTime.exe程序的输出。

时区

时区是一个使用相同标准时间的区域。 世界上有 24 个时区。

  1. UTC = local time + bias

偏差是 UTC 时间与本地时间之间的差异（以分钟为单位）。

检索时区

GetTimeZoneInformation()用于获取时区信息。 信息存储在TIME_ZONE_INFORMATION结构中。

get_time_zone.c

  1. #include <windows.h>
  2. #include <wchar.h>
  4. int wmain(void) {
  6.     TIME_ZONE_INFORMATION tzi = {0};
  8.     int r = GetTimeZoneInformation(&tzi);
  10.     if (r == TIME_ZONE_ID_INVALID) {
  12.         wprintf(L"Failed to get time zone %d", GetLastError());
  13.         return 1;
  14.     }
  16.     wprintf(L"Time zone: %ls\n", tzi.StandardName);
  17.     wprintf(L"The bias is: %ld minutes\n", tzi.Bias);
  19.     return 0;
  20. }

该示例显示用户的时区。

  1. TIME_ZONE_INFORMATION tzi = {0};

TIME_ZONE_INFORMATION结构存储时区的设置。

  1. int r = GetTimeZoneInformation(&tzi);

GetTimeZoneInformation()函数检索当前时区设置。

  1. wprintf(L"Time zone: %ls\n", tzi.StandardName);

TIME_ZONE_INFORMATION结构的StandardName成员存储我们时区的名称。

  1. wprintf(L"The bias is: %ld minutes\n", tzi.Bias);

我们打印偏差值。

  1. C:\Users\Jano\Documents\Pelles C Projects\timedate\GetTimeZone>GetTimeZone.exe
  2. Time zone: Central Europe Standard Time
  3. The bias is: -60 minutes

我们的时区是中欧标准时间（CEST），偏差是 -60 分钟。

将当地时间转换为世界时间

TzSpecificLocalTimeToSystemTime()函数将本地时间转换为 UTC 时间。 该函数考虑了夏令时（DST）对于要转换的当地时间是否有效。

localtime_to_universaltime.c

  1. #include <windows.h>
  2. #include <wchar.h>
  4. int wmain(void) { 
  6.     SYSTEMTIME lt = {0};
  7.     GetLocalTime(&lt);
  9.     TIME_ZONE_INFORMATION tzi = {0};
  10.     GetTimeZoneInformation(&tzi);
  12.     SYSTEMTIME utm = {0};
  14.     int r = TzSpecificLocalTimeToSystemTime(&tzi, &lt, &utm);
  16.     if (r == 0) {
  18.         wprintf(L"Failed to convert local time to system time %d\n)", 
  19.             GetLastError());
  20.         return 1;
  21.     }
  23.     wprintf(L"Date: %d/%d/%d\n", lt.wMonth, lt.wDay, lt.wYear);
  25.     wprintf(L"The local time is: %02d:%02d:%02d\n", 
  26.         lt.wHour, lt.wMinute, lt.wSecond);
  28.     wprintf(L"The universal time is: %02d:%02d:%02d\n", 
  29.         utm.wHour, utm.wMinute, utm.wSecond);
  31.     return 0;
  32. }

该示例将本地时间转换为世界时间。

  1. SYSTEMTIME lt = {0};
  2. GetLocalTime(&lt);

当前的本地时间通过GetLocalTime()函数获取。

  1. TIME_ZONE_INFORMATION tzi = {0};
  2. GetTimeZoneInformation(&tzi);

时区设置由GetTimeZoneInformation()函数确定。

  1. int r = TzSpecificLocalTimeToSystemTime(&tzi, &lt, &utm);

TzSpecificLocalTimeToSystemTime()将夏令时考虑在内，将当地时间转换为世界时间。

  1. wprintf(L"The local time is: %02d:%02d:%02d\n", 
  2.     lt.wHour, lt.wMinute, lt.wSecond);

将本地时间打印到控制台。

  1. wprintf(L"The universal time is: %02d:%02d:%02d\n", 
  2.     utm.wHour, utm.wMinute, utm.wSecond);

世界时间打印到控制台。

  1. C:\Users\Jano\Documents\Pelles C Projects\timedate\LocalTimeToUniversalTime>LocalTimeToUniversalTime.exe
  2. Date: 2/1/2016
  3. The local time is: 11:39:48
  4. The universal time is: 10:39:48

在 2016 年 2 月 1 日的 CEST 时区，我们得到了上述输出。

在 Windows API 教程的这一部分中，我们使用日期&时间。