1

我正在用不使用 MFC/ATL 的主要标准 C++ (VS2010) 编写一个 Windows DLL。

父模块确实使用 MFC 并将 a 传递COleDateTime.m_dt给我的 DLL，它以double. 我相信这是一个 OLE 自动化日期，也称为 OADate。

我想将它转换为任何类型的标准结构（tm ...），它有天、小时等，而不会将 MFC、OLE 等拉入我的 DLL。

之前有人问过这个问题（Convert Date/Time (as Double) to struct* tm in C++）但是，答案总是 using VariantTimeToSystemTime()，这忽略了该问题的重点——不使用 MFC / OLE 等。

VariantTimeToSystemTime 的要求是：

头文件 - OleAuto.h
库 - OleAut32.lib
DLL - OleAut32.dll

我的 DLL 目前基本上没有依赖关系，所以我不希望将 OleAut32.dll 拉入这一转换。

到目前为止，我发现的最好的东西就是这个C# mono code，我可以将它转换为 C++。

4

1 回答 1

1

我有 2 个解决方案，第一个是使用实现的函数，gmtime_r以便该解决方案不使用任何标准函数。第二种解决方案是使用标准函数gmtime_r。

1.第一种解决方案：自己实现gmtime_r( 01-Jan-1601to 31-Dec-9999)：

它适用于 和 之间的01-Jan-1601日期31-Dec-9999。我已经实现了一个fromOADate函数，它使用SO 上SecondsSinceEpochToDateTime的这个答案中的函数，它将之前或之后的秒数转换01-Jan-1970为tm结构，但只能从开始工作01-Jan-1601。

ULL我通过添加一个后缀将函数从该答案更改为也适用于 32 位。这要求long long类型为 64 位宽，如果不是这种情况，此解决方案将不起作用。

如果您需要 1601 年之前的日期，您可以更改它，SecondsSinceEpochToDateTime因为它有据可查。
为了测试不同的值，这个在线转换非常好，它还支持 unix 时间戳和 OADate 类型。

ideone 上的完整工作代码和示例：

#include <iostream>
#include <ctime>
#include <cstring>

struct tm* SecondsSinceEpochToDateTime(struct tm* pTm, uint64_t SecondsSinceEpoch)
{
   uint64_t sec;
   unsigned int quadricentennials, centennials, quadrennials, annuals/*1-ennial?*/;
   unsigned int year, leap;
   unsigned int yday, hour, min;
   unsigned int month, mday, wday;
   static const unsigned int daysSinceJan1st[2][13]=
   {
      {0,31,59,90,120,151,181,212,243,273,304,334,365}, // 365 days, non-leap
      {0,31,60,91,121,152,182,213,244,274,305,335,366}  // 366 days, leap
  };
/*
   400 years:

   1st hundred, starting immediately after a leap year that's a multiple of 400:
   n n n l  \
   n n n l   } 24 times
   ...      /
   n n n l /
   n n n n

   2nd hundred:
   n n n l  \
   n n n l   } 24 times
   ...      /
   n n n l /
   n n n n

   3rd hundred:
   n n n l  \
   n n n l   } 24 times
   ...      /
   n n n l /
   n n n n

   4th hundred:
   n n n l  \
   n n n l   } 24 times
   ...      /
   n n n l /
   n n n L <- 97'th leap year every 400 years
*/

   // Re-bias from 1970 to 1601:
   // 1970 - 1601 = 369 = 3*100 + 17*4 + 1 years (incl. 89 leap days) =
   // (3*100*(365+24/100) + 17*4*(365+1/4) + 1*365)*24*3600 seconds
   sec = SecondsSinceEpoch + 11644473600ULL;

   wday = (uint)((sec / 86400 + 1) % 7); // day of week

   // Remove multiples of 400 years (incl. 97 leap days)
   quadricentennials = (uint)(sec / 12622780800ULL); // 400*365.2425*24*3600
   sec %= 12622780800ULL;

   // Remove multiples of 100 years (incl. 24 leap days), can't be more than 3
   // (because multiples of 4*100=400 years (incl. leap days) have been removed)
   centennials = (uint)(sec / 3155673600ULL); // 100*(365+24/100)*24*3600
   if (centennials > 3)
   {
      centennials = 3;
   }
   sec -= centennials * 3155673600ULL;

   // Remove multiples of 4 years (incl. 1 leap day), can't be more than 24
   // (because multiples of 25*4=100 years (incl. leap days) have been removed)
   quadrennials = (uint)(sec / 126230400); // 4*(365+1/4)*24*3600
   if (quadrennials > 24)
   {
      quadrennials = 24;
   }
   sec -= quadrennials * 126230400ULL;

   // Remove multiples of years (incl. 0 leap days), can't be more than 3
   // (because multiples of 4 years (incl. leap days) have been removed)
   annuals = (uint)(sec / 31536000); // 365*24*3600
   if (annuals > 3)
   {
      annuals = 3;
   }
   sec -= annuals * 31536000ULL;

   // Calculate the year and find out if it's leap
   year = 1601 + quadricentennials * 400 + centennials * 100 + quadrennials * 4 + annuals;
   leap = !(year % 4) && (year % 100 || !(year % 400));

   // Calculate the day of the year and the time
   yday = sec / 86400;
   sec %= 86400;
   hour = sec / 3600;
   sec %= 3600;
   min = sec / 60;
   sec %= 60;

   // Calculate the month
   for (mday = month = 1; month < 13; month++)
   {
      if (yday < daysSinceJan1st[leap][month])
      {
         mday += yday - daysSinceJan1st[leap][month - 1];
         break;
      }
   }

   // Fill in C's "struct tm"
   memset(pTm, 0, sizeof(*pTm));
   pTm->tm_sec = sec;          // [0,59]
   pTm->tm_min = min;          // [0,59]
   pTm->tm_hour = hour;        // [0,23]
   pTm->tm_mday = mday;        // [1,31]  (day of month)
   pTm->tm_mon = month - 1;    // [0,11]  (month)
   pTm->tm_year = year - 1900; // 70+     (year since 1900)
   pTm->tm_wday = wday;        // [0,6]   (day since Sunday AKA day of week)
   pTm->tm_yday = yday;        // [0,365] (day since January 1st AKA day of year)
   pTm->tm_isdst = -1;         // daylight saving time flag

   return pTm;
}


struct tm* fromOADate(struct tm* p_Tm, double p_OADate)
{
   static const int64_t OA_UnixTimestamp = -2209161600; /* 30-Dec-1899 */

   if (!(   -109205 <= p_OADate               /* 01-Jan-1601 */
         &&            p_OADate <= 2958465))  /* 31-Dec-9999 */
   {
      throw std::string("OADate must be between 109205 and 2958465!");
   }

   int64_t OADatePassedDays = p_OADate;
   double  OADateDayTime    = p_OADate - OADatePassedDays;
   int64_t OADateSeconds    = OA_UnixTimestamp
                            + OADatePassedDays * 24LL * 3600LL
                            + OADateDayTime * 24.0 * 3600.0;

   return SecondsSinceEpochToDateTime(p_Tm, OADateSeconds);
}


int main()
{
   struct tm timeVal;

   std::cout << asctime(fromOADate(&timeVal, -109205));         /* 01-Jan-1601 00:00:00 */
   std::cout << asctime(fromOADate(&timeVal, 0));               /* 30-Dec-1899 00:00:00 */
   std::cout << asctime(fromOADate(&timeVal, 25569));           /* 01-Jan-1970 00:00:00 */
   std::cout << asctime(fromOADate(&timeVal, 50424.134803241)); /* 19-Jan-2038 03:14:07 */
   std::cout << asctime(fromOADate(&timeVal, 2958465));         /* 31-Dec-9999 00:00:00 */

   return 0;
}

2.第二种解决方案：使用gmtime_r（01-Jan-1970到19-Jan-2038/ 31-Dec-9999（32/64位））：

如前所述，此解决方案的范围不如上面的变体，但仅使用标准功能（ideone 的完整工作示例）：

#include <iostream>
#include <ctime>

struct tm* fromOADate(struct tm* p_Tm, double p_OADate)
{
   static const int64_t OA_UnixTimestamp = -2209161600; /* 30-Dec-1899 */

   if (!(   25569 <= p_OADate              /* 01-Jan-1970 00:00:00 */
         &&          p_OADate <= 2958465)) /* 31-Dec-9999 00:00:00 */
   {
      throw std::string("OADate must be between 25569 and 2958465!");
   }

   time_t OADatePassedDays = p_OADate;
   double OADateDayTime    = p_OADate - OADatePassedDays;
   time_t OADateSeconds    = OA_UnixTimestamp
                           + OADatePassedDays * 24LL * 3600LL
                           + OADateDayTime * 24.0 * 3600.0;

   /* date was greater than 19-Jan-2038 and build is 32 bit */
   if (0 > OADateSeconds)
   {
      throw std::string("OADate must be between 25569 and 50424.134803241!");
   }

   return gmtime_r(&OADateSeconds, p_Tm);
}


int main()
{
   struct tm timeVal;

   std::cout << asctime(fromOADate(&timeVal, 25569));           /* 01-Jan-1970 00:00:00 */
   std::cout << asctime(fromOADate(&timeVal, 50424.134803241)); /* 19-Jan-2038 03:14:07 */

   return 0;
}
于 2017-07-18T11:13:44.917 回答