Pipe et strucutures

Version imprimable

25/11/2005, 15h26
Vodlich

Pipe et strucutures

Bonjour,

Est-il possible d'envoyer une structure depuis le processus père vers le fils par l'intermedière d'un pipe?
25/11/2005, 16h10
Emmanuel Delahaye

Re: Pipe et strucutures

Citation:

Envoyé par Vodlich

Est-il possible d'envoyer une structure depuis le processus père vers le fils par l'intermedière d'un pipe?

Si elle est 'droite', oui (pas de pointeurs). Je préfère cependant un format texte, c'est plus sûr.

Re: Pipe et strucutures

Merci pour ta réponse,

Arf.. ca m'arrange pas tout ça !

Voici ma structure a communiquer(COMM) :
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 29 typedef struct { /* structure pour stocker les */ int x; /* coordonnees dans la matrice jeu */ int y; } coord; typedef struct pile /*pour stocker les coordonnees*/ { coord valeur; struct pile *prec; } pile ; typedef enum /*pour traiter les messages*/ { LISTE_COMM, ERREUR, ERREUR_ROBOT, ERREUR_MURS, ERREUR_ENERGIE, MURS, ROBOT, ENERGIE } MESSAGE; typedef struct { /* structure pour stocker le */ MESSAGE m; /* type de message et les coordonnees */ pile *p; } COMM;
J'arrive quand même à communiquer la partie MESSAGE de la structure COMM, mais pile, pas moyen(pas 'droite').

Ya t-il un autre moyen pour communiquer cette structure?

Sinon, j'ai un autre problème avec le pipe, quand le père envoie du texte avec un espace, le fils le recois en deux textes coupé au niveau de l'espace et non un bloc texte unique. Comment y remédier ?

26/11/2005, 15h02
Vodlich

Re: Pipe et strucutures

Personne pour m'aider ? :(
26/11/2005, 16h08
Emmanuel Delahaye

Re: Pipe et strucutures

Citation:

Envoyé par Vodlich

Personne pour m'aider ? :(

Soit tu fais un bloc binaire 'droit' (tu linéarises au format format "longueur, donnees", par exemple soit tu convertis en texte. On a pas déjà dit ça ?

Re: Pipe et strucutures

J'ai opté pour la convertion en chaine de caractère (ne sachant pas ce qu'est "un bloc binaire 'droit' (tu linéarises au format format "longueur, donnees")", si c'est possible d'avoir plus d'explication pour infos, je prends!)

Voici le code ma fonction de conversion, j'aimerais avoir l'avis de quelqu'un dessus sachant que la fonction fonctionne mais que je ne maitrise pas les pointeurs et chaines parfaitement.

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
char *convertion_COMM_chaine(COMM mess)
{
	char *temp=malloc(8*longueur_pile(mess.p)*sizeof(char)+3*sizeof(char));
	/* reserve exactement l'espace necessaire pour stocker mess 
	   8 car la chaine finale prend 8 caracteres au maximum pour un maillon de la pile 
	   et 3 pour stocker mess.m et '\0' */
	/* attention, ne marche que pour des coordonnées <100 et >=0*/
 
	char *entier=malloc(3*sizeof(char));
 
	coord c;
 
	switch(mess.m)
	{
		case LISTE : strcpy(temp,"0_");
		break;
 
		case ERREUR : strcpy(temp,"1_");
		break;
 
		case ERREUR_MURS : strcpy(temp,"2_");
		break;
 
		case ERREUR_ENERGIE : strcpy(temp,"3_");
		break;
 
		case ERREUR_ROBOT : strcpy(temp,"4_");
		break;
 
		case MURS : strcpy(temp,"5_");
		break;
 
		case ENERGIE :	strcpy(temp,"6_");		
		break;
 
		case ROBOT : strcpy(temp,"7_");			
		break;
 
		default:
		break;
	}
 
	while(mess.p!=NULL)
	{
 
		c.x=mess.p->valeur.x;
		c.y=mess.p->valeur.y;
 
		sprintf(entier,"(%d,%d)_",c.x,c.y);
 
		strcat(temp,entier);
 
		depiler(&mess.p);
	}
 
	return temp;	
}

et le programme de test

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
29
30
31
32
33
 
int main(void)
{
	char *ch;
 
	COMM mess;
	coord V1;
	coord V2;
	coord V3;
 
	V1.x=10;
	V1.y=12;
 
	V2.x=4;
	V2.y=61;
 
	V3.x=1;
	V3.y=20;
 
	mess.m=ROBOT;
	mess.p=NULL;
 
	empiler(&mess.p,V1);
	empiler(&mess.p,V2);
	empiler(&mess.p,V3);
 
 
	//afficher_pile(mess.p);	
 
	printf("\n%s\n",convertion_COMM_chaine(mess));
 
	return 0;
}

PS : les structures sont celles données dans un post plus haut.

Merci d'avance.

27/11/2005, 14h51
Emmanuel Delahaye

Re: Pipe et strucutures
Citation:

Envoyé par Vodlich

J'ai opté pour la convertion en chaine de caractère (ne

"conversion"

Citation:

sachant pas ce qu'est "un bloc binaire 'droit' (tu linéarises au format format "longueur, donnees")", si c'est possible d'avoir plus d'explication pour infos, je prends!)

Tu définis un format pour les longueurs (par exemple 2 bytes) codés 'réseau', c'est à dire MSB en tête)
Ensuite, tu places tes données de longueur variable dans un tableau bytes.

Par exemple
Code:

1 2 char *pa="Hello"; char *pb="world";
devient

Code:

unsigned char data [] = {0,5,'h','e','l','l','o', 0,5,'w','o','r','l','d'};

je te laisse ecrire le code de conversion. Nota. On trouve en général htons() et ntohs() pour les conversions machine <-> réseau. Sinon

http://emmanuel-delahaye.developpez.com/clib.htm
Module HTON. Attention, ça dépend de la machine.

Citation:

Voici le code ma fonction de conversion, j'aimerais avoir l'avis de

Le principe a l'air correct, mais ce code est incomplet. Il ne compile pas, il n'est pas pas testable.

Re: Pipe et strucutures

Citation:

Envoyé par Emmanuel Delahaye

Citation:

Envoyé par Vodlich

J'ai opté pour la convertion en chaine de caractère (ne

"conversion"

:oops:

Merci pour tes explications mais je vais quand même rester sur ma méthode.

J'ai oublié de mettre les fonctions pour la pile.Voici le code complet :

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
 
#include <stdio.h>
#include<string.h>
#include <stdlib.h>
 
typedef struct
{							/* structure pour stocker les */
	int x;					/* coordonnees dans la matrice jeu */
	int y;
} coord;
 
typedef struct pile /*pour stocker les coordonnees*/
        {
                coord valeur;
                struct pile *prec;
        } pile ;
 
typedef enum /*pour traiter les messages*/
{
	LISTE,
	ERREUR,
	ERREUR_ROBOT,
	ERREUR_MURS,
	ERREUR_ENERGIE,
	MURS,
	ROBOT,
	ENERGIE
} MESSAGE;
 
typedef struct
{							/* structure pour stocker les */
	MESSAGE m;				/* le type de message et les coordonnees */
	pile *p;
} COMM;
 
/*-------------------------------------------------------------------*/
/*		Fonctions de gestion d'une pile */
 
void empiler(pile **p, coord Val)
{
	pile *element = malloc(sizeof(pile));
	if(!element) return;     
	element->valeur = Val;
	element->prec = *p;
	*p = element;       
}
 
void depiler(pile **p)
{
	coord Val;
	pile *tmp;
	if(!*p) exit(1);     
	tmp = (*p)->prec;
	Val = (*p)->valeur;
	free(*p);
	*p = tmp;      
}
 
void raz(pile **p)
{
	pile *tmp;
	while(*p)
	{
		tmp = (*p)->prec;
		free(*p);
		*p = tmp;
	}
}
 
void afficher_pile(pile *p)
{
	while(p)
	{
		printf("(%d,%d) ",p->valeur.x,p->valeur.y);
		p = p->prec;
	}
}
 
int longueur_pile(pile *p)
{
	int n=0;
	while(p)
	{
		n++;
 		p = p->prec;
	}
	return n;
}
 
 
/*-------------------------------------------------------------------*/
 
char *conversion_COMM_chaine(COMM mess)
{
	char *temp=malloc(8*longueur_pile(mess.p)*sizeof(char)+3*sizeof(char));
	/* reserve exactement l'espace necessaire pour stocker mess 
	   8 car la chaine finale prend 8 caracteres au maximum pour un maillon de la pile 
	   et 3 pour stocker mess.m et '\0' */
	/* attention, ne marche que pour des coordonnées <100 et >=0 */
 
	char *entier=malloc(3*sizeof(char));
 
	coord c;
 
	switch(mess.m)
	{
		case LISTE : strcpy(temp,"0_");
		break;
 
		case ERREUR : strcpy(temp,"1_");
		break;
 
		case ERREUR_MURS : strcpy(temp,"2_");
		break;
 
		case ERREUR_ENERGIE : strcpy(temp,"3_");
		break;
 
		case ERREUR_ROBOT : strcpy(temp,"4_");
		break;
 
		case MURS : strcpy(temp,"5_");
		break;
 
		case ENERGIE :	strcpy(temp,"6_");		
		break;
 
		case ROBOT : strcpy(temp,"7_");			
		break;
 
		default:
		break;
	}
 
	while(mess.p!=NULL)
	{
 
		c.x=mess.p->valeur.x;
		c.y=mess.p->valeur.y;
 
		sprintf(entier,"(%d,%d)_",c.x,c.y);
 
		strcat(temp,entier);
 
		depiler(&mess.p);
	}
 
	return temp;	
}
 
int main(void)
{
	char *ch;
 
	COMM mess;
	coord V1;
	coord V2;
	coord V3;
 
	V1.x=10;
	V1.y=12;
 
	V2.x=4;
	V2.y=61;
 
	V3.x=1;
	V3.y=20;
 
	mess.m=ROBOT;
	mess.p=NULL;
 
	empiler(&mess.p,V1);
	empiler(&mess.p,V2);
	empiler(&mess.p,V3);
 
 
	afficher_pile(mess.p);	
 
	printf("\n%s\n",conversion_COMM_chaine(mess));
 
	raz(&mess.p);
 
	return 0;
}

Re: Pipe et strucutures

Citation:

Envoyé par Vodlich

J'ai oublié de mettre les fonctions pour la pile.Voici le code complet :

Un petit coup de detecteur de mensonges...

Code:

1
2
3
4
5
6
 
SYSALLOC Bloc 003D2510 freed at line 65 of 'main.c' not allocated
SYSALLOC Bloc 003D24F8 freed at line 65 of 'main.c' not allocated
SYSALLOC Bloc 003D24E0 freed at line 65 of 'main.c' not allocated
SYSALLOC Bloc 003D2528 (27 bytes) malloc'ed at line 95 of 'main.c' not freed
SYSALLOC Bloc 003D2470 (3 bytes) malloc'ed at line 101 of 'main.c' not freed

Visiblement, il y a un petit problème de libération des ressources...

Simplification (inutile d'allouer un tableau de taille fixe), instrumentation du code :

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
 
#include "ed/inc/sys.h"
 
#include <stdio.h>
#include<string.h>
#include <stdlib.h>
 
typedef struct
{                     /* structure pour stocker les */
    int x;               /* coordonnees dans la matrice jeu */
    int y;
}
coord;
 
typedef struct pile /*pour stocker les coordonnees*/
{
    coord valeur;
    struct pile *prec;
}
pile ;
 
typedef enum /*pour traiter les messages*/
{
    LISTE,
    ERREUR,
    ERREUR_ROBOT,
    ERREUR_MURS,
    ERREUR_ENERGIE,
    MURS,
    ROBOT,
    ENERGIE
} MESSAGE;
 
typedef struct
{                     /* structure pour stocker les */
    MESSAGE m;            /* le type de message et les coordonnees */
    pile *p;
}
COMM;
 
/*-------------------------------------------------------------------*/
/*      Fonctions de gestion d'une pile */
 
void empiler(pile **p, coord Val)
{
    pile *element = malloc(sizeof(pile));
    if(!element)
        return;
    element->valeur = Val;
    element->prec = *p;
    *p = element;
}
 
void depiler(pile **p)
{
    coord Val;
    pile *tmp;
    if(!*p)
        exit(1);
    tmp = (*p)->prec;
    Val = (*p)->valeur;
    free(*p);
    *p = tmp;
}
 
void raz(pile **p)
{
    pile *tmp;
    while(*p)
    {
        tmp = (*p)->prec;
        free(*p);
        *p = tmp;
    }
}
 
void afficher_pile(pile *p)
{
    while(p)
    {
        printf("(%d,%d) ",p->valeur.x,p->valeur.y);
        p = p->prec;
    }
}
 
int longueur_pile(pile *p)
{
    int n=0;
    while(p)
    {
        n++;
        p = p->prec;
    }
    return n;
}
 
 
/*-------------------------------------------------------------------*/
 
char *conversion_COMM_chaine(COMM mess)
{
    size_t size_temp = 8 * longueur_pile (mess.p) + 3;
    char *temp = malloc (size_temp);
    if (temp != NULL)
    {
        LIM_PTR(temp, size_temp);
 
        /* reserve exactement l'espace necessaire pour stocker mess
           8 car la chaine finale prend 8 caracteres au maximum pour un maillon de la pile
           et 3 pour stocker mess.m et '\0' */
        /* attention, ne marche que pour des coordonnées <100 et >=0 */
 
        coord c;
 
        switch(mess.m)
        {
            case LISTE :
            strcpy(temp,"0_");
            break;
 
            case ERREUR :
            strcpy(temp,"1_");
            break;
 
            case ERREUR_MURS :
            strcpy(temp,"2_");
            break;
 
            case ERREUR_ENERGIE :
            strcpy(temp,"3_");
            break;
 
            case ERREUR_ROBOT :
            strcpy(temp,"4_");
            break;
 
            case MURS :
            strcpy(temp,"5_");
            break;
 
            case ENERGIE :
            strcpy(temp,"6_");
            break;
 
            case ROBOT :
            strcpy(temp,"7_");
            break;
 
            default:
            break;
        }
 
        while(mess.p!=NULL)
        {
            char entier[3];
            LIM_STR(entier);
 
            c.x=mess.p->valeur.x;
            c.y=mess.p->valeur.y;
 
            sprintf(entier,"(%d,%d)_",c.x,c.y);
            CHK_STR(entier);
 
            strcat(temp,entier);
            CHK_PTR(temp,size_temp );
 
            depiler(&mess.p);
 
        }
    }
    return temp;
}
 
int main(void)
{
    char *ch;
 
    COMM mess;
    coord V1;
    coord V2;
    coord V3;
 
    V1.x=10;
    V1.y=12;
 
    V2.x=4;
    V2.y=61;
 
    V3.x=1;
    V3.y=20;
 
    mess.m=ROBOT;
    mess.p=NULL;
 
    empiler(&mess.p,V1);
    empiler(&mess.p,V2);
    empiler(&mess.p,V3);
 
 
    afficher_pile(mess.p);
 
    printf("\n%s\n",conversion_COMM_chaine(mess));
 
    raz(&mess.p);
 
    return 0;
}

Ca donne :

Code:

1
2
3
4
5
6
7
8
9
10
11
 
(1,20) (4,61) (10,12) SYS: assertion '(entier)[sizeof (entier) - 1]==0' failed a
t main.c:161
SYS: SYS_print_stack() : Undefined in ISO-C
SYS: *** EXIT ***
SYSALLOC min=4294967295 max=4294967295 delta=0
SYSALLOC Err: Not-matched list:
SYSALLOC Bloc 003D24E0 (12 bytes) malloc'ed at line 45 of 'main.c' not freed
SYSALLOC Bloc 003D24F8 (12 bytes) malloc'ed at line 45 of 'main.c' not freed
SYSALLOC Bloc 003D2510 (12 bytes) malloc'ed at line 45 of 'main.c' not freed
SYSALLOC Bloc 003D2528 (27 bytes) malloc'ed at line 102 of 'main.c' not freed

Ca signifie en clair que le tableau de 3 char est trop petit...

On s'en serait un peu douté...

Le code manquant est là :

http://emmanuel-delahaye.developpez.com/clib.htm

27/11/2005, 15h35
Vodlich

Re: Pipe et strucutures

Je ne comprend pas ce que tout ça veut dire. :?:
27/11/2005, 15h36
Emmanuel Delahaye

Re: Pipe et strucutures

Citation:

Envoyé par Vodlich

Je ne comprend pas ce que tout ça veut dire. :?:

Tu parles de quoi ? Bouton [Citer] please...

Re: Pipe et strucuturesB

Deja, si je comprend bien, ce code

Code:

LIM_PTR(temp, size_temp);

est équivalent à :

Code:

(temp)[(size_temp) -1]=0;

.
Si c'est bien ça, je ne comprend pas ce qu'il fait. Idem pour

Code:

LIM_STR(entier);

Code:

CHK_STR(entier);

Code:

CHK_PTR(temp,size_temp );

Sinon, si je modifie la déclaration de entier comme ceci :

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
char *conversion_COMM_chaine(COMM mess)
{
	char *temp=malloc(8*longueur_pile(mess.p)*sizeof(char)+3*sizeof(char));
	/* reserve exactement l'espace necessaire pour stocker mess 
	   8 car la chaine finale prend 8 caracteres au maximum pour un maillon de la pile 
	   et 3 pour stocker mess.m et '\0' */
	/* attention, ne marche que pour des coordonnées <100 et >=0 */
 
	char entier[9];
 
	coord c;
 
	switch(mess.m)
	{
		case LISTE : strcpy(temp,"0_");
		break;
 
		case ERREUR : strcpy(temp,"1_");
		break;
 
		case ERREUR_MURS : strcpy(temp,"2_");
		break;
 
		case ERREUR_ENERGIE : strcpy(temp,"3_");
		break;
 
		case ERREUR_ROBOT : strcpy(temp,"4_");
		break;
 
		case MURS : strcpy(temp,"5_");
		break;
 
		case ENERGIE :	strcpy(temp,"6_");		
		break;
 
		case ROBOT : strcpy(temp,"7_");			
		break;
 
		default:
		break;
	}
 
	while(mess.p!=NULL)
	{
		c.x=mess.p->valeur.x;
		c.y=mess.p->valeur.y;
 
		sprintf(entier,"(%d,%d)_",c.x,c.y);
 
		strcat(temp,entier);
 
		depiler(&mess.p);
	}
 
	return temp;	
}

c'est pas suffisant ?

Re: Pipe et strucuturesB

Citation:
Envoyé par Vodlich
Deja, si je comprend bien, ce code

Code:

LIM_PTR(temp, size_temp);

est équivalent à :

Code:

(temp)[(size_temp) -1]=0;

.
Si c'est bien ça, je ne comprend pas ce qu'il fait. Idem pour

Citation:

Il place un 0 en fin de chaine.

Code:

LIM_STR(entier);

Citation:

Pareil sauf que comme c'est un tableau et non un pointeur, il n'a pas besoin de la taille.

Code:

CHK_STR(entier);

Code:

CHK_PTR(temp,size_temp );

Citation:

Ces macros vérifient que le 0 est toujours là. Si on a débordé, il n'y est plus, et le programme s'arrête.

Cette technique permet de faire de l'instrumentation, c'est à dire de mettre en évidence certains comportements indéfinis en les rendant prévisibles. (Ici, les débordements de chaines, qui sont une des principales causes de problèmes dans un programme C, la preuve...)

Sinon, si je modifie la déclaration de entier comme ceci :
Code:

1 2 3 4 5 6 7 char *conversion_COMM_chaine(COMM mess) { char *temp=malloc(8*longueur_pile(mess.p)*sizeof(char)+3*sizeof(char)); /* reserve exactement l'espace necessaire pour stocker mess 8 car la chaine finale prend 8 caracteres au maximum pour un maillon de la pile et 3 pour stocker mess.m et '\0' */ /* attention, ne marche que pour des coordonnées <100 et >=0 */
Attention, malloc() peut échouer. J'avais ajouté un test. Je perd mon temps ou quoi ?
Citation:
Code:

1 2 char entier[9];
Il n'est pas pratique de définir une variable loin de son utilisation... Il suffit qu'elle soit en tête de bloc...

Citation:

c'est pas suffisant ?

En tout cas, chez moi, ça ne casse plus. iL reste encore des problèmes de libération de la mémoire...

Certaines adresses sont libérées 2 fois, d'autres pas du tout...
Code:

1 2 3 4 5 6 7 8 (1,20) (4,61) (10,12) 7_(1,20)_(4,61)_(10,12)_ SYSALLOC Err: Not-matched list: SYSALLOC Bloc 003D2510 freed at line 71 of 'main.c' not allocated SYSALLOC Bloc 003D24F8 freed at line 71 of 'main.c' not allocated SYSALLOC Bloc 003D24E0 freed at line 71 of 'main.c' not allocated SYSALLOC Bloc 003D2528 (27 bytes) malloc'ed at line 102 of 'main.c' not freed

Re: Pipe et strucutures

J'ai ajouté le test sur le malloc(), désolé.

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
char *conversion_COMM_chaine(COMM mess)
{
	char *temp=malloc(8*longueur_pile(mess.p)*sizeof(char)+3*sizeof(char));
	/* reserve exactement l'espace necessaire pour stocker mess 
	   8 car la chaine finale prend 8 caracteres au maximum pour un maillon de la pile 
	   et 3 pour stocker mess.m et '\0' */
	/* attention, ne marche que pour des coordonnées <100 et >=0 */
 
	if(temp!=NULL)
	{
		switch(mess.m)
		{
			case LISTE : strcpy(temp,"0_");
			break;
 
			case ERREUR : strcpy(temp,"1_");
			break;
 
			case ERREUR_MURS : strcpy(temp,"2_");
			break;
 
			case ERREUR_ENERGIE : strcpy(temp,"3_");
			break;
 
			case ERREUR_ROBOT : strcpy(temp,"4_");
			break;
 
			case MURS : strcpy(temp,"5_");
			break;
 
			case ROBOT :	strcpy(temp,"6_");		
			break;
 
			case ENERGIE : strcpy(temp,"7_");			
			break;
 
			default:
			break;
		}
 
		while(mess.p!=NULL)
		{
			char entier[9];
			coord c;
 
			c.x=mess.p->valeur.x;
			c.y=mess.p->valeur.y;
 
			sprintf(entier,"(%d,%d)_",c.x,c.y);
 
			strcat(temp,entier);
 
			depiler(&mess.p);
		}
                raz(&mess.p);
	}	
	return temp;	
}

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
29
30
31
32
33
int main(void)
{
	char *ch;
 
	COMM mess;
	coord V1;
	coord V2;
	coord V3;
 
	V1.x=10;
	V1.y=12;
 
	V2.x=4;
	V2.y=61;
 
	V3.x=1;
	V3.y=20;
 
	mess.m=ERREUR;
	mess.p=NULL;
 
	empiler(&mess.p,V1);
	empiler(&mess.p,V2);
	empiler(&mess.p,V3);
 
 
	afficher_pile(mess.p);	
	ch=conversion_COMM_chaine(mess);
	printf("\n%s\n",ch);
	free(ch);
 
	return 0;
}

Je pense que tout est libéré.

27/11/2005, 17h20
Emmanuel Delahaye

Re: Pipe et strucutures
Citation:

Envoyé par Vodlich

J'ai ajouté le test sur le malloc(), désolé.
Je pense que tout est libéré.

C'est OK.

Attention, comme conversion_COMM_chaine() peut retourner NULL :
Code:

1 2 3 4 5 6 7 ch = conversion_COMM_chaine (mess); if (ch != NULL) { printf ("\n%s\n",ch); free (ch); }
Et aussi, prendre l'habitude de forcer le pointeur à NULL une fois libéré. Ca facilite la mise au point...

Code:

free (ch), ch = NULL;

Je passe sur les conventions de nommage...

http://emmanuel-delahaye.developpez.com/codage.htm
27/11/2005, 17h23
Vodlich

Re: Pipe et strucutures

C'est nickel tout ça :D
Un grand merci à toi Emmanuel Delahaye pour m'avoir consacré de ton temps.
A+ sur le forum.