Wie konvertieren von UTC in die lokale Zeit in C?

Wenn man davon ausgehen kann POSIX (und damit die POSIX-Spezifikation von time_t als Sekunden seit Beginn der Epoche), würde ich den ersten verwenden die POSIX-Formel zum konvertieren in Sekunden seit Beginn der Epoche:

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

Nächstes verwenden localtime((time_t []){0}) zu bekommen struct tm repräsentiert die Epoche, in der lokalen Zeit. Fügen Sie die Sekunden seit der Epoche der tm_sec Feld dieses struct tm sind, dann rufen Sie mktime zu kanonisieren es.

Edit: Eigentlich nur POSIX-Abhängigkeit ist, dass eine bekannte Epoche, die (time_t)0 entspricht. Vielleicht können Sie einen Weg finden, um Sie, wenn Sie wirklich brauchen, um... beispielsweise über Aufrufe beide gmtime und localtime bei time_t 0..

Edit 2: Eine Skizze, wie dies zu tun:

#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);
}

Bitte nicht Sinn der hässliche Ausgabe-code. Dieses Programm nimmt ein argument in der form "Sekunden relativ zu den POSIX epoch" und gibt den resultierenden Zeit in lokale Zeit. Sie können konvertieren UTC-Zeit in Sekunden seit der Epoche, mit der Formel, die ich oben zitiert. Beachten Sie, dass dieser code nicht in irgendeiner Weise davon abhängen, POSIX, aber es nimmt der offset zurückgegeben diff_tm Kombination mit dem Sekunden-seit-die-Epoche-Wert nicht überlaufen int. Eine Lösung für dieses Problem wäre die Verwendung einer long long offset und eine Schleife, die hält das hinzufügen von Schritten, die nicht größer als INT_MAX/2 (oder kleiner als INT_MIN/2) und ruft mktime zu renormalize, bis der offset-Wert 0 erreicht.

Sum-up: die Umwandlung von kaputten Datum (struct tm) in UTC zu einem (lokalen) Kalender-Zeit (time_t) erreicht, die mit timegm() - das Gegenteil von mktime() - ABER timegm() ist keine standard-Funktion (wie die Logik ist, dass).
Der C-standard lässt uns nur mit time(), gmtime(), mktime() und difftime().

Einen workaround gefunden, in anderen docs berät zu emulieren timegm (), indem Sie zuerst die Umgebungsvariable TZ auf einen null-string, dann der Aufruf von mktime (), die sich in UTC-Kalender-Zeit, zurücksetzen von TZ auf seinen ursprünglichen Wert, aber noch einmal, dies ist nicht standard.

Grundsätzlich, so wie ich es verstehe, ist der Unterschied zwischen der lokalen Zeit und der UTC-Zeit ist nur ein offset, so dass, wenn wir beurteilen können, der ausgeglichen ist, können wir passen Sie das Ergebnis von mktime(), also hier ist mein Vorschlag:

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);
}

Einem quick-test:

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;
}

Fand ich, dass die Lösung bei der OP gab funktionierte nicht in den Fällen, wenn die Sommerzeit gilt. Zum Beispiel, in meinem Fall, zum aktuellen Zeitpunkt die Sommerzeit wurde nicht in Kraft ist, aber wenn ich das erste Datum, das konvertiert lokale Zeit mit DST, dann würde es nicht funktionieren, D. H. das heutige Datum ist 3/1/2018 und die Sommerzeit ist nicht in Kraft, aber wenn ich den Zeitpunkt für die Konvertierung in, sagen wir, 8/1/2018 0:00:00 wenn DST ist in Kraft, dann ist die Lösung gegeben würde, zu konvertieren, um die lokale Zeit, aber nicht die Sommerzeit berücksichtigt. Ich fand, dass die Initialisierung e0 auf das Datum und die Stunde, in der die ursprünglichen Datums - /Zeit-string und den tm_isdst zu -1 das problem gelöst. Dann habe ich das folgende Programm mit komplementären Funktionen, die Sie können in Ihrem code. Die anfängliche format des Datums und der Uhrzeit ist die gleiche, die MySQL benutzt, weil ich brauchte es für solche Zwecke.

#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;
}

Folgte ich der Antwort von @Dachschaden und ich habe ein Beispiel, das zeigt auch lesbare Ausgabe und ich entfernen Sie die DST-option für die Differenz in Sekunden zwischen UTC-Zeit und lokaler Zeit. Hier ist es:

#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;
}

Ausgabe auf meinem Rechner ist:

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

UTC in seconds: 1462462751
LOCAL in seconds: 1462448351

Beachten Sie, dass die Sommerzeit ist in diesem Fall (es gibt eine 1-Stunden-time zone offset-Differenz zwischen UTC-Zeit und LOKALER Ebene).

Einen einfachen und effektiven Weg: Addieren (bzw. subtrahieren) Sie die Anzahl der Sekunden, die zwischen Ihrer Zeitzone und UTC (unter Berücksichtigung der Sommerzeit).

Als ein Beispiel, das funktioniert nur vor einer minute, am Dezember 30, 2017, US Mountain Standard Time (DST), die 7 Stunden hinter UTC:

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

Genießen.