pb fonction date dans structure tm

Version imprimable

Bonjour,
J'ai réalisé une fontion qui découpe une date au format YYYY-MM-DDTHH:MM:SS.sss et range les éléments dans une structure tm. Cette fonction marche, elle est codée comme suit:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
struct tm *fDateT_To_Struct(char *strdate) {
 
 static struct tm returndate;
 sscanf(strdate,"%4d-%2d-%2dT%2d:%2d:%2d.%3d",&(returndate.tm_year)
				             ,&(returndate.tm_mon)
				             ,&(returndate.tm_mday)
					,&(returndate.tm_hour)
					,&(returndate.tm_min)
				    	,&(returndate.tm_sec)
				             ,&(returndate.tm_isdst));
	returndate.tm_wday = 0;
  	returndate.tm_yday = 0;
 
	return &returndate ;
}

Maintenant, je souhaite inclure un code de retour d'erreur RetCode à ma fonction. J'ai modifié ma fonction comme suit:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
RetCode fDateT_To_Struct(char *strdate, struct tm *st_dateStruct) {
 
	RetCode retCode;
	int i=0; 
	static struct tm returndate;
 
	i = sscanf(strdate,"%4d-%2d-%2dT%2d:%2d:%2d.%3d"
                                                                       ,&(returndate.tm_year)
				                    ,&(returndate.tm_mon)
				                    ,&(returndate.tm_mday)
					       ,&(returndate.tm_hour)
					       ,&(returndate.tm_min)
				    	       ,&(returndate.tm_sec)
				                   ,&(returndate.tm_isdst));
	returndate.tm_wday = 0;
  	returndate.tm_yday = 0;
	st_dateStruct = &returndate;
 
	if (i<0) goto error;
	else goto fin;
 
error:
	retCode = NOK;
fin:
	retCode = OK;
 
return(retCode);
}

Mais lorsqu'un j'appelle ma fonction, cela ne marche plus!
(bout de code du main:)

Code:

1
2
3
4
5
6
7
8
struct tm *pt_Str;
char  carac[25]; 
RetCode retcode; /*RetCode type prédéfini: accepte OK ou NOK*/
 
strcpy(carac, "2002-11-03T23:45:01.556");
 
retCode = fDateT_To_Struct(carac, pt_Str);
printf("pt_Str-> tm_year: %d\n",pt_Str->tm_year); /*par exemple*/

Il y a une erreur à l'exécution:

Code:

1
2
signal SEGV (no mapping at the fault address) in main at line 111 in file "mon_fichier.c"
  111                   printf("pt_Str-> tm_year: %d\n",pt_Str->tm_year);

Je ne maîtrise pas bien les pointeurs de structure. Quelqu'un aurait-t-il une idée?
Merci beaucoup
Sandra

:tagcode:

Moi, je ferais plutôt un truc dans ce genre-là:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
RetCode fDateT_To_Struct(char const *sDate, struct tm *pDateStruct)
{
int i=0;
 
/* Contrôle des paramètres */
if(sDate==NULL || pDateStruct==NULL)
	return NOK;
 
i = sscanf(sDate,"%4d-%2d-%2dT%2d:%2d:%2d.%3d",
 &(pDateStruct->tm_year),
 &(pDateStruct->tm_mon),
 &(pDateStruct->tm_mday),
 &(pDateStruct->tm_hour),
 &(pDateStruct->tm_min),
 &(pDateStruct->tm_sec),
 &(pDateStruct->tm_isdst)
 );
pDateStruct->tm_wday = 0;
pDateStruct->tm_yday = 0;
 
return ((i==7) ? OK : NOK);
}

28/11/2006, 10h14
sandra771

Ah oui merci, j'y penserai la prochaine fois.
J'ai testé ta solution, ça plante à l'exécution sur:

signal SEGV (no mapping at the fault address) in number at 0xfea8c918
0xfea8c918: number+0x085c: st %i1, [%o0]
Current function is fDateT_To_Struct
439 );

Sandra
28/11/2006, 10h20
Médinoc

Comment appelles-tu la fonction ?
PS: J'ai oublié un test dans le contrôle des paramètres, je viens de le rajouter.
28/11/2006, 10h37
Fabllot

Il me semble, que ta variable "pt_Str" de type "tm*" n'est jamais allouée... A moins que sscanf le fasse (mais j'en doute), il manque sans doute un "malloc" quelque part, non ?

Comme suit:

Code:

1
2
3
4
5
6
7
8
9
10
11
 
RetCode retCode;
struct tm *pt_Str;
char date[25];
 
strcpy(date, "2002-05-11T22:12:45.123");
 
retCode = fDateT_To_Struct(date, pt_Str);		
if (retCode != OK) {
/*gestion d'erreur*/		
}

Sandra

C'est à dire, mal.
Code:

1 2 3 4 5 6 7 8 9 10 RetCode retCode; struct tm Str; char date[25] = ""; /* ou char date[25]={0};*/ strncpy(date, "2002-05-11T22:12:45.123", 25-1); retCode = fDateT_To_Struct(date, &Str); if (retCode != OK) { /*gestion d'erreur*/ }
Tu passais un pointeur non-initialisé à la fonction. Plantage pratiquement garanti, avec ou sans le test que j'avais oublié. Tu espérais que la fonction modifie le pointeur, alors que les variables sont passées par valeur en C ?

28/11/2006, 10h46
Fabllot

Citation:

Envoyé par Fabllot

Il me semble, que ta variable "pt_Str" de type "tm*" n'est jamais allouée... A moins que sscanf le fasse (mais j'en doute), il manque sans doute un "malloc" quelque part, non ?

Petite précision :
Dans le code de Sandra, je ne suis pas sûr que cela soit très "propre", mais grâce à la déclaration d'une structure "static" ça doit fonctionner (du moins pas de problèmes mémoire ici)...

Cependant, ma remarque concernait en fait la modification du code par Medinoc, qui du coup remplit une structure non allouée...

D'accord, je ne maitrise pas encore les pointeurs. Mais maintenant, j'ai le problème qui est reporté car utilisant une structure et non plus un pointeur de structure, je veux appeler un autre fonction qui à partir de la structure tm construit une date au format DD/MM/YYYY HH:MM:SS et les millisecondes.
Mais celle-ci accepte un pointeur de struture en entrée!
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 RetCode fDateT_To_Date(struct tm *Struct, char *Date, char *micro) { RetCode retCode; int i=0; int j=0; i = sprintf (Date , "%02d/%02d/%4d %02d:%02d:%02d", Struct->tm_mday, Struct->tm_mon, Struct->tm_year, Struct->tm_hour, Struct->tm_min, Struct->tm_sec); j = sprintf(micro, "%3d", Struct->tm_isdst); if ((i < 0) && (j < 0)) goto error; else goto fin; error: retCode = NOK; fin: retCode = OK; return(retCode); }
Comment je fais pour l'appeler?
Avant, je faisais comme ça (quand j'avais déclaré un pointeur de structure et non une structure...)
Code:

1 2 3 4 5 6 retCode = fDateT_To_Date(pt_Str, Date, DateMs); if (retCode != OK) { /* gestion d'erreur */ }
Merci pour votre aide

J'ai trouvé! Je modifie ma fonction comme suit:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 RetCode fDateT_To_Date(struct tm Struct, char *Date, char *micro) { RetCode retCode; int i=0; int j=0; i = sprintf (Date , "%02d/%02d/%4d %02d:%02d:%02d", &(Struct.tm_mday), &(Struct.tm_mon), &(Struct.tm_year), &(Struct.tm_hour), &(Struct.tm_min), &(Struct.tm_sec)); j = sprintf(micro, "%3d", &(Struct.tm_isdst)); if ((i < 0) && (j < 0)) goto error; else goto fin; error: retCode = NOK; fin: retCode = OK; return(retCode); }
et je l'appelle comme avant.
Merci pour toutes votre aide et remarques. Mais je sens que je ne maîtrise pas encore tout ça comme il faut.
Auriez-vous une bonne référence de bouquin sur les pointeurs et structures?
Sandra

28/11/2006, 11h12
Fabllot

Citation:

Envoyé par sandra771

Auriez-vous une bonne référence de bouquin sur les pointeurs et structures?
Sandra

http://c.developpez.com/livres/#L2100490184
28/11/2006, 11h15
Fabllot
Il vaut mieux faire quelque chose comme ça :
Code:

1 2 3 4 5 6 RetCode fDateT_To_Date(struct tm *Struct, char *Date, char *micro) { [...] j = sprintf(micro, "%3d", Struct->tm_isdst); [...] }
que ceci
Code:

1 2 3 4 5 6 RetCode fDateT_To_Date(struct tm Struct, char *Date, char *micro) { [...] j = sprintf(micro, "%3d", &(Struct.tm_isdst)); [...] }
Dans le premier, tu passe un pointeur vers la structure, alors que dfans le second tu fais une copie de l'objet...
Certes, dans le premier cas, il faut faire très attention aux déclarations / allocations / initialisations, mais c'est plus sûr...
28/11/2006, 15h33
Emmanuel Delahaye

Citation:

Envoyé par Fabllot

Dans le code de Sandra, je ne suis pas sûr que cela soit très "propre", mais grâce à la déclaration d'une structure "static" ça doit fonctionner (du moins pas de problèmes mémoire ici)...

Cependant, ma remarque concernait en fait la modification du code par Medinoc, qui du coup remplit une structure non allouée...

Non, c'est crade. On écrit pas du code crade pour cause de "problèmes mémoire". On apprend à programmer et on écrit du code propre et utilisable partout, y compris avec des threads...

Ne pas mélanger code et données. Jamais. Travailler par contexte. C'est toujours l'appelant qui est responsable de ses données, (en cas d'allocation dynamique dans la fonction, l'adresse est retournée à l'appelant qui en est responsable, de même que de la libération).

La code de Medinoc est correct. C'est l'appel qui est faux. Le compilateur aurait pu le signaler...