[C] Conversion de dates (j'ai perdu 2h !!!)

Conversion de dates (j'ai perdu 2h !!!) [C] - C - Programmation

Marsh Posté le 09-10-2003 à 16:38:04    

Je cherche à écrire 2 fonction de conversion de date:
 
L'une qui me transforme un timestamp  "SQL-compliant" en timestamp en seconde (utc):

Code :
  1. char* DAT_SecondsToTimestamp(unsigned long seconds) {
  2. struct tm* time = NULL;
  3. static char timestamp[DAT_TIMESTAMP_SIZE] = "";
  4. //---
  5. time = gmtime(&seconds);
  6. sprintf(timestamp, "%02d-%02d-%02d %02d:%02d:%02d", time->tm_mday, time->tm_mon+1, (1900+time->tm_year)%1000, time->tm_hour, time->tm_min, time->tm_sec);
  7. return timestamp;
  8. }


 
L'autre fait la conversion inverse

Code :
  1. unsigned long DAT_TimestampToSeconds(char* timestamp) {
  2. char tmp[3];
  3. struct tm* time = NULL;
  4. //---
  5. time = (struct tm*)malloc(sizeof(struct tm));
  6. strncpy(tmp, &timestamp[DAT_TIMESTAMP_SS_POS], 2);
  7. time->tm_sec = atoi(tmp);
  8. strncpy(tmp, &timestamp[DAT_TIMESTAMP_MI_POS], 2);
  9.   time->tm_min = atoi(tmp);
  10. strncpy(tmp, &timestamp[DAT_TIMESTAMP_HH_POS], 2);
  11.   time->tm_hour = atoi(tmp);
  12. strncpy(tmp, &timestamp[DAT_TIMESTAMP_DD_POS], 2);
  13.   time->tm_mday = atoi(tmp);
  14. strncpy(tmp, &timestamp[DAT_TIMESTAMP_MM_POS], 2);
  15.   time->tm_mon = atoi(tmp) - 1;
  16. strncpy(tmp, &timestamp[DAT_TIMESTAMP_YY_POS], 2);
  17.   time->tm_year = atoi(tmp) + 100;
  18. time->tm_wday = 0;
  19.   time->tm_yday = 0;
  20.   time->tm_isdst = 1;
  21. return mktime(time);
  22. }


 
Mais cette dernière ne fonctionne pas correctement. Je "perd" 2h00 ... comme par hasard c'est le décalage horaire GMT.
 
1) Est-ce que je cherche compliqué et il existe une autre manière de faire ça ?
 
2) Sinon ... ben aidez moi !
 
Petit exemple:

Code :
  1. printf("1065705799 = %s\n", DAT_SecondsToTimestamp(1065705799));
  2. printf("09-10-03 13:23:19 = %d\n", toto = DAT_TimestampToSeconds("09-10-03 13:23:19" ));
  3. printf("Time = %s\n", DAT_SecondsToTimestamp(toto));


 
M'affiche ça:
1065705799 = 09-10-03 15:23:19
09-10-03 13:23:19 = 1065698599
Time = 09-10-03 13:23:19
 
PS: les constante:
#define DAT_TIMESTAMP_SIZE 17+1 // Format 'DD-MM-YY HH:MI:SS'
#define DAT_TIMESTAMP_DD_POS 0
#define DAT_TIMESTAMP_MM_POS 3
#define DAT_TIMESTAMP_YY_POS 6
#define DAT_TIMESTAMP_HH_POS 9
#define DAT_TIMESTAMP_MI_POS 12
#define DAT_TIMESTAMP_SS_POS 15


Message édité par mog le 09-10-2003 à 16:39:46
Reply

Marsh Posté le 09-10-2003 à 16:38:04   

Reply

Marsh Posté le 09-10-2003 à 18:41:08    

euh gmtime
 
localtime peut être  
 
edit : je fais comment pour aider si je suis de nouveau soumis à cette limitation à la con
 
 
pourquoi tu fais pas un sscanf ?
 
sscanf(timestamp, "%02d-%02d-%02d %02d:%02d:%02d", &time->tm_mday, &time->tm_mon+1, ...
 
c'est symétrique, fait ça, àa sera plus claire, on verra après.
 
ok pour le static, par contre dans le deuxième, tu as une fuite de mémoire : utiliser une vairable auto, pas besoin d'allocation dynamique. utlise des time_t au lieu de unsigned long


Message édité par Taz le 09-10-2003 à 19:23:56
Reply

Marsh Posté le 09-10-2003 à 18:53:29    

Code :
  1. const char* DAT_SecondsToTimestamp(time_t seconds)
  2. {
  3.   static char timestamp[DAT_TIMESTAMP_SIZE] = "";
  5.   struct tm *t = localtime(&seconds);
  7.   sprintf(timestamp, "%02d-%02d-%02d %02d:%02d:%02d",
  8.   t->tm_mday,
  9.   t->tm_mon+1,
  10.   t->tm_year%100,
  11.   t->tm_hour,
  12.   t->tm_min,
  13.   t->tm_sec
  14.   );
  15.   return timestamp;
  16. }
  19. time_t DAT_TimestampToSeconds(const char* timestamp)
  20. {
  21.   time_t now=time(NULL);
  22.   struct tm t=*localtime(&now);
  24.   sscanf(timestamp, "%d-%d-%d %d:%d:%d",
  25.   &t.tm_mday,
  26.   &t.tm_mon,
  27.   &t.tm_year,
  28.   &t.tm_hour,
  29.   &t.tm_min,
  30.   &t.tm_sec
  31.   );
  32.   t.tm_mon-=1;
  33.   t.tm_year+=100;
  35.   return mktime(&t);
  36. }


Message édité par Taz le 09-10-2003 à 19:31:33
Reply

Marsh Posté le 09-10-2003 à 18:54:43    

et utilise strftime également

Reply

Marsh Posté le 10-10-2003 à 08:26:04    

1) Si j'utilise gmtime c'est que je doit travaille avec l'heure universelle gmt.
 
2) En effet j'avais pas pensé au sscanf ... c'est quand même plus lisible !
 
3) OK pour la fuite, j'ai fait une chtite boulette.
 
4) J'ai essayé ta solution:


MOG
1065705799 = 09-10-03 13:23:19
09-10-03 13:23:19 = 1065698599
1065698599 = 09-10-03 11:23:19
 
TAZ
1065705799 = 09-10-03 15:23:19
09-10-03 13:23:19 = 1065698599
1065698599 = 09-10-03 13:23:19


 
J'ai toujours ma perte de 2h ... avec 2h de décalage horaire !


Message édité par mog le 10-10-2003 à 10:07:42
Reply

Marsh Posté le 10-10-2003 à 10:10:38    

ben tu perds 2 heures par rapport à l'heure locale, pas par rapport à la gmt, faudrait savoir...  
 
parce que figure toi qu'entre Paris et Greenwich, il y a un décalage horaire

Reply

Marsh Posté le 10-10-2003 à 10:21:32    

Je perd bien 2h par rapport à l'heure gmt:
 
1065705799 = 09-10-03 13:23:19 (gmt) et 15:23:19 (local)
 
Pourquoi est-ce que j'obtient 11:23:19 (en plein atlantique !) à la 2ème conversion ?


Message édité par mog le 10-10-2003 à 10:24:15
Reply

Marsh Posté le 10-10-2003 à 11:10:42    

J'ai le même soucis en utilisant des fonctions:
 

Code :
  1. long DAT_Today() {
  2.   struct timeval tp; 
  3.   struct timezone tzp; 
  4.   gettimeofday(&tp, &tzp);
  5.   return tp.tv_sec;
  6. }
  8. /* permet de passer à minuit (début) du jour suivant */
  9. long DAT_NextDay(long timestamp) {
  10.   struct tm t;
  11.   timestamp += DAT_24H_IN_SECONDS; // ajoute 86400 sec
  12.   t = *gmtime(&timestamp);
  13.   t.tm_hour = 0;
  14.   t.tm_min = 0;
  15.   t.tm_sec = 0;
  16.   t.tm_isdst = 1;
  17.   return mktime(&t);
  18. }
  19. int main() {
  20.   time_t toto;
  21.   toto = DAT_Today();
  22.   printf("Today = %d -> %s\n", toto, DAT_SecondsToTimestamp(toto));
  23.   toto = DAT_NextDay(toto);
  24.   printf("Tomorrow = %d -> %s\n", toto, DAT_SecondsToTimestamp(toto));
  25. }


 
Resultat:
Today    = 1065776523 -> 10-10-03 09:02:03
Tomorrow = 1065823200 -> 10-10-03 22:00:00
 
Et je passe à 22h00 du même jour ... manque encore 2h !

Reply

Marsh Posté le 10-10-2003 à 14:11:41    

Up

Reply

Marsh Posté le 10-10-2003 à 14:20:29    

t'es un vrai boolay toi ...


Message édité par Taz le 10-10-2003 à 14:20:38
Reply

Marsh Posté le 10-10-2003 à 14:20:29   

Reply

Marsh Posté le 10-10-2003 à 14:55:16    

Taz a écrit :

t'es un vrai boolay toi ...


 
Précise ta pensée ...

Reply

Marsh Posté le 10-10-2003 à 15:22:45    

micne, il y a gmtime et deux heures de décalages ...

Reply

Marsh Posté le 10-10-2003 à 15:34:15    

Relis mon post plus attentivement STP avant de te foutre de moi ... tiens ça me rappelle un autre topic, on ne change pas une équipe qui gagne !
 
Tiens d'ailleurs le décalage entre locale et GMT est de 1h normalement ...

Reply

Marsh Posté le 10-10-2003 à 15:35:04    

ou 2h suivant la saison

Reply

Marsh Posté le 10-10-2003 à 15:49:05    

Ca ne répond toujours pas à la question ...

Reply

Marsh Posté le 10-10-2003 à 15:55:48    

heink ?

Reply

Marsh Posté le 10-10-2003 à 16:01:15    

c'est ton PC qui est mal configuré ...
 

Code :
  1. #include <stdio.h>
  2. #include <time.h>
  5. const char* DAT_SecondsToTimestamp(time_t seconds)
  6. {
  7.   static char timestamp[100] = "";
  8.    
  9.   struct tm *t = localtime(&seconds);
  10.    
  11.   sprintf(timestamp, "%02d-%02d-%02d %02d:%02d:%02d",
  12.   t->tm_mday,
  13.   t->tm_mon+1,
  14.   t->tm_year%100,
  15.   t->tm_hour,
  16.   t->tm_min,
  17.   t->tm_sec
  18.   );
  19.   return timestamp;
  20. }
  21.  
  22.  
  23. time_t DAT_TimestampToSeconds(const char* timestamp)
  24. {
  25.   time_t now=time(NULL);
  26.   struct tm t=*localtime(&now); /* initialisation correcte*/
  27.   /* ou alors memset(&t, 0, sizeof t) */
  28.    
  29.   sscanf(timestamp, "%d-%d-%d %d:%d:%d",
  30.  &t.tm_mday,
  31.  &t.tm_mon,
  32.  &t.tm_year,
  33.  &t.tm_hour,
  34.  &t.tm_min,
  35.  &t.tm_sec
  36.  );
  37.   t.tm_mon-=1;
  38.   t.tm_year+=100;
  39.    
  40.   return mktime(&t);
  41. }
  44. long DAT_Today()
  45. {
  46.        
  47.   return time(NULL);
  48. }
  49.  
  50. /* permet de passer à minuit (début) du jour suivant */
  51. long DAT_NextDay(long timestamp) {
  52.   struct tm t;
  53.   timestamp += 86400; /* ajoute 86400 sec */
  54.   t = *gmtime(&timestamp);
  55.   t.tm_hour = 0;
  56.   t.tm_min = 0; 
  57.   t.tm_sec = 0;
  58.   t.tm_isdst = 1;
  59.   return mktime(&t);
  60. }
  61. int main() {
  62.   time_t toto;
  63.   toto = DAT_Today();
  64.   printf("Today = %lu -> %s\n", toto, DAT_SecondsToTimestamp(toto));
  65.   toto = DAT_NextDay(toto);
  66.   printf("Tomorrow = %lu -> %s\n", toto, DAT_SecondsToTimestamp(toto));
  67.   return 0;
  68. }


 
 
Today = 1065794458 -> 10-10-03 16:00:58
Tomorrow = 1065823200 -> 11-10-03 00:00:00


Message édité par Taz le 10-10-2003 à 16:03:26
Reply

Marsh Posté le 10-10-2003 à 16:17:30    

Encore une fois, tu travailles en localtime.
 
Moi, j'ai besoin de bosser en GMT ! Et c'est ça qui pose pb !

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed