10

这是一个简单的问题,但解决方案似乎远非简单。我想知道如何从UTC转换为当地时间。我正在寻找一种标准的 C 语言解决方案,或多或少保证可以在任何位置的任何计算机上工作。

我已仔细阅读以下链接,但在那里找不到解决方案:

在C中将包含本地时间的字符串转换为UTC

在 C/C++ 中在当地时间和 GMT/UTC 之间转换

我尝试了许多变体,例如(datetime 是一个带有 UTC 时间和日期的字符串):

strptime(datetime, "%A %B %d %Y %H %M %S", tp);
strftime(printtime, strlen(datetime), "%A %B %d %Y %H %M %S", tp);

或者

strptime(datetime, "%A %B %d %Y %H %M %S", tp);
lt=mktime(tp);
printtime=ctime(&lt);

无论我尝试什么 printtime 最终都与 UTC 相同。

编辑 11-29-2013:基于下面“R”的非常有用的答案,我终于开始创建一个工作示例。我发现它在我测试的两个时区 CET 和 PST 中工作正常:

#include <time.h>
#include <stdio.h>
#include <stdlib.h>

long long diff_tm(struct tm *a, struct tm *b)
{
  return a->tm_sec - b->tm_sec
          +60LL*(a->tm_min - b->tm_min)
          +3600LL*(a->tm_hour - b->tm_hour)
          +86400LL*(a->tm_yday - b->tm_yday)
          +(a->tm_year-70)*31536000LL
          -(a->tm_year-69)/4*86400LL
          +(a->tm_year-1)/100*86400LL
          -(a->tm_year+299)/400*86400LL
          -(b->tm_year-70)*31536000LL
          +(b->tm_year-69)/4*86400LL
          -(b->tm_year-1)/100*86400LL
          +(b->tm_year+299)/400*86400LL;
}


int main()
{
  time_t utc, local;
  char buf[100];
  const char datetime[]="2013 11 30 23 30 26 UTC"; /* hard coded date and time in UTC */

  struct tm *tp=malloc(sizeof(struct tm));
  if(tp==NULL)
    exit(-1);

  struct tm *localt=malloc(sizeof(struct tm));
  if(localt==NULL)
    exit(-1);

  memset(tp, 0, sizeof(struct tm));
  memset(localt, 0, sizeof(struct tm));

  printf("UTC date and time to be converted in local time: %s\n", datetime);

  /* put values of datetime into time structure *tp */
  strptime(datetime, "%Y %m %d %H %M %S %z", tp);

  /* get seconds since EPOCH for this time */
  utc=mktime(tp);
  printf("UTC date and time in seconds since EPOCH: %d\n", utc);

  /* lets convert this UTC date and time to local date and time */

  struct tm e0={ .tm_year = 70, .tm_mday = 1 }, e1, new;
  /* get time_t EPOCH value for e0 (Jan. 1, 1970) */
  time_t pseudo=mktime(&e0);

  /* get gmtime for this value */
  e1=*gmtime(&pseudo);

  /* calculate local time in seconds since EPOCH */
  e0.tm_sec += utc - diff_tm(&e1, &e0);

  /* assign to local, this can all can be coded shorter but I attempted to increase clarity */
  local=e0.tm_sec;
  printf("local date and time in seconds since EPOCH: %d\n", local);

  /* convert seconds since EPOCH for local time into localt time structure */
  localt=localtime(&local);

  /* get nicely formatted human readable time */
  strftime(buf, sizeof buf, "%Y-%m-%d %H:%M:%S %Z", localt);

  printf("local date and time: %s\n", buf);
}

它应该在大多数系统上编译没有问题。我用 UTC 硬编码了一个时间和日期,然后将其转换为本地时间和日期。

4

10 回答 10

6

如果您可以假设 POSIX(因此 POSIX 规范time_t自纪元以来的秒数),我将首先使用 POSIX 公式转换为自纪元以来的秒数:

tm_sec + tm_min*60 + tm_hour*3600 + tm_yday*86400 +
    (tm_year-70)*31536000 + ((tm_year-69)/4)*86400 -
    ((tm_year-1)/100)*86400 + ((tm_year+299)/400)*86400

接下来,用于localtime((time_t []){0})获取struct tm表示本地时间的纪元。将自纪元以来的秒数添加到tm_secthis 的字段中struct tm,然后调用mktime以对其进行规范化。

编辑:实际上唯一的 POSIX 依赖项是具有(time_t)0对应的已知时代。如果你真的需要的话,也许你可以找到一种解决方法......例如使用对两者的调用gmtime以及localtimetime_t0..

编辑2:如何做到这一点的草图:

#include <time.h>
#include <stdio.h>

long long diff_tm(struct tm *a, struct tm *b)
{
        return a->tm_sec - b->tm_sec
                +60LL*(a->tm_min - b->tm_min)
                +3600LL*(a->tm_hour - b->tm_hour)
                +86400LL*(a->tm_yday - b->tm_yday)
                +(a->tm_year-70)*31536000LL
                -(a->tm_year-69)/4*86400LL
                +(a->tm_year-1)/100*86400LL
                -(a->tm_year+299)/400*86400LL
                -(b->tm_year-70)*31536000LL
                +(b->tm_year-69)/4*86400LL
                -(b->tm_year-1)/100*86400LL
                +(b->tm_year+299)/400*86400LL;
}

int main(int argc, char **argv)
{
        char buf[100];
        struct tm e0 = { .tm_year = 70, .tm_mday = 1 }, e1, new;
        time_t pseudo = mktime(&e0);
        e1 = *gmtime(&pseudo);
        e0.tm_sec += atoi(argv[1]) - diff_tm(&e1, &e0);
        mktime(&e0);
        strftime(buf, sizeof buf, "%c", &e0);
        puts(buf);
}

请不要介意丑陋的输出代码。该程序采用“相对于 POSIX 纪元的秒数​​”形式的参数,并以本地时间输出结果时间。您可以使用我上面引用的公式将任何 UTC 时间转换为自纪元以来的秒数。请注意,此代码不以任何方式依赖于 POSIX,但它确实假设diff_tm结合 seconds-since-the-epoch 值返回的偏移量不会溢出int。对此的解决方法是使用一个long long偏移量和一个循环,该循环不断添加不大于INT_MAX/2(或小于)的增量INT_MIN/2)并调用mktime重新规范化,直到偏移量达到 0。

于 2012-01-31T08:58:42.520 回答
5

啊...我可能只是 C 的初学者,但我得到了这个工作示例:

#include <time.h>
#include <stdio.h>
int main(void)
{
        time_t abs_ts,loc_ts,gmt_ts;
        struct tm loc_time_info,gmt_time_info;

        /*Absolute time stamp.*/
        time(&abs_ts);

        /*Now get once the local time for this time stamp,
        **and once the GMT (UTC without summer time) time stamp.*/
        localtime_r(&abs_ts,&loc_time_info);
        gmtime_r(&abs_ts,&gmt_time_info);

        /*Convert them back.*/
        loc_ts=mktime(&loc_time_info);
        gmt_ts=mktime(&gmt_time_info);

        /*Unfortunately, GMT still has summer time. Get rid of it:*/
        if(gmt_time_info.tm_isdst==1)
                {gmt_ts-=3600;}

        printf("Local timestamp: %lu\n"
                "UTC timestamp: %lu\n"
                "Difference in hours: %lu\n\n",
                loc_ts,
                gmt_ts,
                (loc_ts-gmt_ts)/3600);

        return 0;
}

产生这个输出:

本地时间戳:1412554119

格林威治标准时间:1412546919

小时差异:2

现在您可以了解 UTC 和本地时间之间的差异(以秒为单位)。这应该足以转换它。

对您的代码的一个注释, aseq:您在这里不需要使用 malloc(您也可以在堆栈上 memset 值,并且 malloc 可能很昂贵,而堆栈分配通常要快得多),并且您不释放它。这是非常非常糟糕的做法。

另一件事:

memset(tp, 0, sizeof(struct tm));

如果你将 sizeof(*tp) (或者,如果你将 tp 放在堆栈上,sizeof(tp)) 传递给 memset 会更好。这样可以确保即使您的对象类型发生变化,它仍然是完全 memset。

于 2014-10-06T00:10:53.920 回答
3

总结一下:使用 timegm() 将 UTC 中的细分日期 (struct tm) 转换为(本地)日历时间 (time_t) - 与 mktime() 相反 - 但 timegm() 不是标准功能(这是多么的逻辑)。C 标准只给我们留下了 time()、gmtime()、mktime() 和 difftime()。

在其他文档中找到的解决方法建议通过首先将环境变量 TZ 设置为空字符串来模拟 timegm(),然后调用 mktime() 生成 UTC 日历时间,然后将 TZ 重置为其初始值,但再一次,这是不标准。

基本上,据我了解,本地时间和 UTC 时间之间的差异只是一个偏移量,所以如果我们可以评估该偏移量,我们可以调整 mktime() 的结果,所以这是我的建议:

time_t my_timegm(struct tm *tm) {
    time_t epoch = 0;
    time_t offset = mktime(gmtime(&epoch));
    time_t utc = mktime(tm);
    return difftime(utc, offset);
}

快速测试:

int main(void) {
    time_t now = time(0);
    struct tm local = *localtime(&now);
    struct tm utc = *gmtime(&now);
    time_t t1 = mktime(&local);
    time_t t2 = my_timegm(&utc);
    assert(t1 == t2);
    printf("t =%lu\nt1=%lu\nt2=%lu\n",now,t1,t2);
    return 0;
}
于 2012-07-16T09:24:16.367 回答
2
//working stand alone function adjusting UTC to local date and time
//globals(unsigned integers): gps.Mth, gps.Yr, gps.Hm (eg:2115 for 21:15)
//adjust date and time according to UTC
//tz(timezone) eg: 1100, for 11 hours, tzdir: 1 forward, 0 backwards            





    void AdjustUTCToTimeZone(u16 tz, u8 tzdir){
    u8 maxDayInAnyMonth[13] = {0,31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; //gps.Mth 1-12 (not zero)
        if(gps.Yr%4==0){maxDayInAnyMonth[2]=29;}//adjust for leapyear
        u8 maxDayUtcMth =maxDayInAnyMonth[gps.Mth];
        u8 maxDayPrevMth=maxDayInAnyMonth[gps.Mth-1];
        if(!maxDayPrevMth){maxDayPrevMth=31;} //month before utc month

        u16 hr=(gps.Hm/100)*100;u16 m=gps.Hm-hr;  //2115 --> 2100 hr and 15 min
        if(tzdir){//adjusting forwards
            tz+=gps.Hm;
            if(tz>2400){gps.Hm=tz-2400;gps.Day++;                //spill over to next day
                  if(gps.Day>maxDayUtcMth){ gps.Day=1;gps.Mth++; //spill over to next month
                      if(gps.Mth>12){gps.Mth=1; gps.Yr++;        //spill over to next year
                      }
                  }
            }else{gps.Hm=tz;}
        }else{//adjusting backwards
            if(tz>gps.Hm){gps.Hm=(2400-(tz-hr))+m;gps.Day--;  // back to previous day
                  if(gps.Day==0){                             //back to previous month
                     gps.Mth--;gps.Day=maxDayPrevMth;
                     if(!gps.Mth){gps.Mth=12;                 //back to previous year
                        gps.Yr--;
                     }
                  }
            }else{gps.Hm-=tz;}
        }
    }
于 2017-08-10T10:13:51.810 回答
1

我发现 OP 提供的解决方案在适用 DST 的情况下不起作用。例如,在我的情况下,在当前时间,DST 没有生效,但是如果我设置了应该使用DST 转换为本地时间的初始日期,那么它将不起作用,即今天的日期是 2018 年 3 月 1 日和DST 无效,但如果我将转换日期设置为,例如,当 DST 生效时 8/1/2018 0:00:00 那么给出的解决方案将转换为本地时间,但不会将 DST 转换为帐户。我发现初始化e0为初始日期/时间字符串及其成员的日期和tm_isdst小时-1解决了这个问题。然后,我创建了以下程序,其中包含可以包含在代码中的补充功能。日期和时间的初始格式与 MySQL 使用的相同,因为我为此需要它。

#include <stdio.h>
#include <time.h>
#include <string.h>

long long diff_tm(struct tm *a, struct tm *b) {
 return a->tm_sec - b->tm_sec
      + 60LL * (a->tm_min - b->tm_min)
      + 3600LL * (a->tm_hour - b->tm_hour)
      + 86400LL * (a->tm_yday - b->tm_yday)
      + (a->tm_year - 70) * 31536000LL
      - (a->tm_year - 69) / 4 * 86400LL
      + (a->tm_year - 1) / 100 * 86400LL
      - (a->tm_year + 299) / 400 * 86400LL
      - (b->tm_year - 70) * 31536000LL
      + (b->tm_year - 69) / 4 * 86400LL
      - (b->tm_year - 1) / 100 * 86400LL
      + (b->tm_year + 299) /400 * 86400LL;
}

void localToUTC(char *buf, const char *localTime) {
 struct tm tp;
 strptime(localTime, "%Y-%m-%d %H:%M:%S", &tp);
 tp.tm_isdst = -1;
 time_t utc = mktime(&tp);
 struct tm res = *gmtime(&utc);
 strftime(buf, 20, "%Y-%m-%d %H:%M:%S", &res);
}

void utcToLocal(char *buf, const char *utcTime) {
 struct tm tp;
 strptime(utcTime, "%Y-%m-%d %H:%M:%S", &tp);
 tp.tm_isdst = -1;
 time_t utc = mktime(&tp);
 struct tm e0 = { .tm_year = tp.tm_year, .tm_mday = tp.tm_mday, .tm_mon = tp.tm_mon, .tm_hour = tp.tm_hour, .tm_isdst = -1 };
 time_t pseudo = mktime(&e0);
 struct tm e1 = *gmtime(&pseudo);
 e0.tm_sec += utc - diff_tm(&e1, &e0);
 time_t local = e0.tm_sec;
 struct tm localt = *localtime(&local);
 strftime(buf, 20, "%Y-%m-%d %H:%M:%S", &localt);
}

int main(void) {
 char mytime_1[20] = "2018-02-28 13:00:00";
 char utctime_1[20], back_1[20];
 localToUTC(utctime_1, mytime_1);
 utcToLocal(back_1, utctime_1);
 printf("My time: %s\n", mytime_1);
 printf("UTC time: %s\n", utctime_1);
 printf("Back: %s\n", back_1);

 printf("-------------------------------------------\n");

 char mytime_2[20] = "2018-07-28 17:00:00";
 char utctime_2[20], back_2[20];
 localToUTC(utctime_2, mytime_2);
 utcToLocal(back_2, utctime_2);
 printf("My time: %s\n", mytime_2);
 printf("UTC time: %s\n", utctime_2);
 printf("Back: %s\n", back_2);

 printf("-------------------------------------------\n");

 return 0;
}
于 2018-03-01T07:45:55.300 回答
1

我认为这比那更容易;time.h 定义了三个变量:

extern int    daylight;
extern long   timezone;
extern char  *tzname[];

调用时根据 TZ env 变量加载

 tzset();

如果你有 UTC 时间

struct tm date;
date.tm_isdst = 0;

使用 mktime 将其转换为 time_t

time_t utc = mktime( &date );

然后将其转换为当地时间

time_t local = utc - timezone + ( daylight?3600:0 );

timezone 是当前时区距 UTC 的秒数,而夏令时为 1 表示夏令时正在播放,零表示不播放。

一个小警告:当我为微控制器编写代码并交叉编译时,是 time.h 用初始下划线定义了这些变量。

请参见 time.h 的手册页

于 2018-07-05T08:50:10.110 回答
0

我按照@Dachschaden 的回答做了一个示例,该示例还显示了人类可读的输出,并且我删除了 DST 选项以显示 UTC 和本地时间之间的秒数差异。这里是:

#include <time.h>
#include <stdio.h>

#define DATE_MAX_STR_SIZE 26
#define DATE_FMT "%FT%TZ%z"

int main() {

    time_t now_time, now_time_local;
    struct tm now_tm_utc, now_tm_local;
    char str_utc[DATE_MAX_STR_SIZE];
    char str_local[DATE_MAX_STR_SIZE];

    time(&now_time);
    gmtime_r(&now_time, &now_tm_utc);
    localtime_r(&now_time, &now_tm_local);

    /* human readable */
    strftime(str_utc, DATE_MAX_STR_SIZE, DATE_FMT, &now_tm_utc);
    strftime(str_local, DATE_MAX_STR_SIZE, DATE_FMT, &now_tm_local);

    printf("\nUTC: %s", str_utc);
    printf("\nLOCAL: %s\n", str_local);

    /* seconds (epoch) */
    /* let's forget about DST for time difference calculation */
    now_tm_local.tm_isdst = 0;
    now_tm_utc.tm_isdst = 0;
    now_time_local = now_time + (mktime(&now_tm_local) - mktime(&now_tm_utc));

    printf("\nUTC in seconds: %lu", now_time);
    printf("\nLOCAL in seconds: %lu\n", now_time_local);

    return 0;
}

我机器上的输出是:

UTC: 2016-05-05T15:39:11Z-0500
LOCAL: 2016-05-05T11:39:11Z-0400

UTC in seconds: 1462462751
LOCAL in seconds: 1462448351

请注意,在这种情况下 DST 处于启用状态(UTC 和 LOCAL 之间存在 1 小时的时区偏移差异)。

于 2016-05-05T15:38:34.630 回答
0

试试这个,测试输出:utcEpochTime: 1487652688, localEpochTime: 1487699488, diff: 46800

$ python
>>>46800 / 60 / 60
13

差异是 13 小时,这很好,因为我的时区是 UTC+8。

#include <stdio.h>
#include <time.h>

int main(int argc, char *argv[])
{
    time_t utcEpochTime = time(0);
    time_t localEpochTime = 0;

    struct tm tm = {0};
    localtime_r(&utcEpochTime, &tm);
    tm.tm_isdst = -1;
    localEpochTime = timegm(&tm);

    printf("utcEpochTime: %d, localEpochTime: %d, diff: %d\n", (int)utcEpochTime, (int)localEpochTime, (int)(localEpochTime - utcEpochTime));
    return 0;
}
于 2017-02-21T04:55:50.007 回答
0

一种简单有效的方法:添加(或减去)您的时区和 UTC 之间的秒数(考虑夏令时)。

举个例子,在一分钟前,即 2017 年 12 月 30 日,使用美国山区标准时间(无 DST),比 UTC 晚 7 小时:

time_t     current_time_UTC;
time_t     current_time_MST;

struct tm *current_broken_time_MST;

uint32_t seven_hours_in_seconds = 25200; // Get this any way you want

current_time_UTC = time (NULL);                                 // UTC
current_time_MST = current_time_UTC - seven_hours_in_seconds;   // MST

current_broken_time_MST = localtime (&current_time_MST);        // MST

享受。

于 2017-12-31T03:32:40.607 回答
-8
void   CTestDlg::OnBtnTest()   
{ 
HANDLE   hFile; 
WIN32_FIND_DATA   wfd; 
SYSTEMTIME   systime; 
FILETIME   localtime; 
char   stime[32];     //
memset(&wfd,   0,   sizeof(wfd)); 

if((hFile=FindFirstFile( "F:\\VC\\MFC\\Test\\Release\\Test.exe ",        &wfd))==INVALID_HANDLE_VALUE) 
{ 
char   c[2]; 
DWORD   dw=GetLastError(); 
wsprintf(c,   "%d ",   dw); 
AfxMessageBox(c);   
return   ;//
} 
FileTimeToLocalFileTime(&wfd.ftLastWriteTime,&localtime); 
FileTimeToSystemTime(&localtime,&systime); 
sprintf(stime, "%4d-%02d-%02d   %02d:%02d:%02d ", 
      systime.wYear,systime.wMonth,systime.wDay,systime.wHour, 
      systime.wMinute,systime.wSecond); 
AfxMessageBox(stime);   
} 
于 2012-01-31T08:35:19.507 回答