Comment faire pour convertir de l'heure UTC en heure locale en C?

Si vous pouvez supposer POSIX (et donc la spécification POSIX de time_t en secondes depuis l'époque), je voudrais tout d'abord utiliser la POSIX formule pour convertir de secondes depuis l'epoch:

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

Ensuite, utilisez localtime((time_t []){0}) pour obtenir un struct tm représentant de l'époque dans l'heure locale. Ajouter les secondes depuis l'époque de la tm_sec champ de cette struct tm, puis d'appeler mktime à accepter.

Edit: en Fait la seule POSIX dépendance est d'avoir connu une époque qui (time_t)0 correspond à. Peut-être vous pouvez trouver un moyen de contourner cela, si vous avez vraiment besoin de... par exemple à l'aide d'appels à la fois gmtime et localtime à time_t 0..

Edit 2: Une esquisse de la façon de le faire:

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

S'il vous plaît ne pas l'esprit de la laide de code de sortie. Ce programme prend un argument sous la forme de "secondes par rapport à la norme POSIX époque" et les sorties de l'résultant heure en heure locale. Vous pouvez convertir n'importe quelle heure UTC de secondes depuis l'epoch à l'aide de la formule que j'ai cité ci-dessus. Notez que ce code ne dépend en aucune façon POSIX, mais il suppose le décalage retourné par diff_tm combiné avec le nombre de secondes depuis l'epoch valeur ne déborde pas int. Un correctif pour ce qui serait d'utiliser un long long offset et une boucle qui ne cesse d'ajouter de incréments pas plus grand que INT_MAX/2 (ou plus petit que INT_MIN/2) et de l'appel de mktime d'effectuer une renormalisation jusqu'à ce que le décalage atteint 0.

OriginalL'auteur R..

Pour résumer: la conversion d'un ventilées date (struct tm) UTC à un (local) calendar time (time_t) est réalisé avec timegm() - à l'opposé de mktime() - MAIS timegm() n'est pas une fonction standard (la façon dont la logique est que).
Le C standard, nous laisse avec seulement de temps(), gmtime(), mktime() et difftime().

Une solution de contournement trouvé dans d'autres docs conseille à émuler timegm() en définissant d'abord la variable d'environnement TZ pour une chaîne nulle, alors l'appel de mktime() résultant en une heure UTC calendrier de temps, puis réinitialiser la LIMITE de sa valeur initiale, mais encore une fois, ce n'est pas la norme.

Fondamentalement, ce que je comprends, la différence entre l'heure locale et l'heure UTC est juste un décalage de sorte que si nous pouvons évaluer que l'offset, nous pouvons ajuster le résultat de mktime(), voici donc ma proposition:

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

Un test rapide:

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

OriginalL'auteur 0xFC

J'ai trouvé que la solution de l'OP a donné ne fonctionne pas dans les cas où l'heure s'applique. Par exemple, dans mon cas, à l'heure actuelle, l'heure d'été n'était pas en effet, mais si j'ai mis la date initiale qui devraient se convertir à l'heure locale avec de l'heure d'été, alors il ne serait pas de travail, c'est à dire la date d'aujourd'hui est 3/1/2018 et de l'heure d'été n'est pas en effet, mais si j'ai mis la date de la conversion, disons, 8/1/2018 0:00:00 lorsque l'heure d'été est en effet, alors la solution serait de convertir à l'heure locale, mais de ne pas prendre en compte de l'heure d'été. J'ai trouvé que l'initialisation d' e0 à la date et l'heure de la première chaîne de date/heure et de ses états tm_isdst à -1 résolu le problème. Ensuite, j'ai créé le programme suivant avec des fonctions complémentaires que vous pouvez inclure dans votre code. Le format de la date et de l'heure est la même que MySQL utilise, car j'en avais besoin pour de telles fins.

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

OriginalL'auteur Nikola Novak

J'ai suivi la réponse par @Dachschaden et j'ai fait un exemple qui montre également lisible par l'homme, de sortie et je supprime l'option de l'heure d'été pour la différence en secondes entre l'heure UTC et l'heure locale. Ici, il est:

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

Sortie sur ma machine est:

UTC: 2016-05-05T15:39:11Z-0500
LOCAL: 2016-05-05T11:39:11Z-0400
UTC in seconds: 1462462751
LOCAL in seconds: 1462448351

Noter que l'heure d'été est sur dans ce cas (il y a 1 heure de décalage horaire décalage entre l'heure UTC et l'heure LOCALE).

OriginalL'auteur ChisholmKyle

Un moyen simple et efficace: Ajouter (ou soustraire) le nombre de secondes entre votre fuseau horaire et l'heure UTC (en tenant compte de l'heure d'été).

Comme un exemple qui a très bien fonctionné il y a une minute, sur décembre 30, en 2017, avec les états-UNIS Heure normale des rocheuses (pas de DST), qui est de 7 heures derrière 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

Profiter.

OriginalL'auteur user3341673