Discussion :

[siempre]

Bonjour,

J'ai fait un programme théoriquement se passe bien.
la compilation se passe bien. mais lorsque je lance l'exécution je n'obtiens pas le résultat souhaité.
J'ai fait ce programme C avec visual studio 2008 alors l'exécution ne passe bien
de plus j'ai vérifié ceci avec code blocks alors j'obtiens ce message après l'exécution:

Process terminated with status -1073741819 <0*COOOOOO5>


C'est urgent je suis sur que mon programme est bien fait.
J'ai besoin de votre aide car je suis bloqué.

Merci.

[Franck.H]

C'est urgent je suis sur que mon programme est bien fait.

Bin il faudrait peut-être qu'on le vois ce programme tu crois pas ?

[siempre]

Bonjour,

J'ai voulu composer mon problèmes en sous problèmes pour que soit lisible.
Je vous explique le problème en totalité:
chaque ligne de fichier contient une chaine de caractère(ensemble des mots)
Je voulais afficher les lignes qui existent dans "f.txt" et n'existent pas dans "f1.txt"
selon deux critères :
- ignorance de l'ordre entre les mots de chaque ligne par exemple
"a b c" est identique à "a b c"
aussi "a b c" est identique à "b a c"

- inclusion par exemple:
"a b" inclut dans "a b c"

le premier but est d'afficher les lignes de fichier "f.txt" qui ne sont pas identiques et non pas incluses dans "f1.txt"

de même on affiche les lignes de fichier "f.txt" qui ne sont pas identiques et non pas incluses dans "f2.txt"

de même on affiche les lignes de fichier "f.txt" qui ne sont pas identiques et non pas incluses dans "f3.txt"

Voici un exemple:
J'ai un fichier de base qui doit être exister qui s'appelle "f.txt"
Soit le fichier "f.txt":
a b
a c
a d
b c
b d
c d
a b c
a b d
b c d
a c d
a b c d

et j'ai d'autres fichiers qui leur nombre varie. Mais au moins j'ai un et je peux avoir N fichiers.
Supposons que on a N=3.
Donc on a 3 fichiers respectivement: "f1.txt", "f2.txt" et "f3.txt"
Soit "f1.txt" :
a
d a
c a
b c a

Soit "f2.txt" :
a
c
b
d
b a
d a
b c
d c
b c a

Soit "f3.txt" :
a
b
c
c a
d a
b a
b c
b c a

Je voudrais chercher comme j'ai dit avant les lignes qui appartiennent au "f.txt" et qui vérifient les deux conditions c'est à dire : l'ignorance de l'ordre et inclusion.

Je vais appliquer votre idée successivement entre:
- "f.txt" et "f1.txt"
- "f.txt" et "f2.txt"
- "f.txt" et "f3.txt"

C'est bon j'obtiens le résultat pour:
- "f.txt" et "f1.txt"
b d
c d
a b d
b c d
a c d
a b c d

- "f.txt" et "f2.txt"
b d
a b d
b c d
a c d
a b c d

- "f.txt" et "f3.txt"
b d
c d
a b d
b c d
a c d
a b c d

Le deuxième but est de chercher l'intersection entre ces résultats obtenus (comparaison entre 2 fichiers).
Mon idée est de sauvegarder le résultat d'appel de la fonction "is_same()" c'est à dire au lieu d'afficher dans la console alors c'est mieux de sauvegarder le résultat dans un fichier ou un tableau.
Puis on fait l'intersection entre les résultats sauvegardés .

Le résultat souhaité obtenu à la fin est :
b d
a b d
b c d
a c d
a b c d

Enfin, le but final nous cherchons dans ce résultat la ligne qui n'est pas incluse dans les autres lignes de ce même résultat.
on a :
"a b d" contient "b d"
"b c d" contient "b d"
"a b c d" contient "b d"

Et donc nous obtenons le résultat final de ce problème:
b d
a c d

Dans ce code j'ai le premier but
pour le 2 ème et le but final ne sont pas terminés donc j'ai les met en commentaires.
il faut que le premier but se passe bien pour continuer le reste de mon travail.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
 
#include <stdio.h>
 
#include <stdlib.h>
 
#include <string.h>
 
 
 
#define MAX_SIZE 1024
 
 
 
char* strndup(const char *str, size_t n)
 
{
 
  char *ret = malloc((n+1) * sizeof (char));
 
 
 
  if (!ret)
 
    exit(0);  strncpy(ret, str, n);
 
  ret[n] = 0;
 
 
 
  return ret;
 
}
 
 
 
void free_tab(char** t)
 
{
 
  char** head = t;
 
 
 
  while (t && *t)
 
  {
 
    free(*t);
 
    t++;
 
 
 
  }
 
  free(head);
 
}
 
 
 
char** get_word(const char* str)
 
{
 
  char* pos = NULL;
 
  char** res = NULL;
 
  int nb = 0;
 
 
 
  do
 
  {
 
    int size = 0;
 
 
 
    pos = strchr(str, ' ');
 
    if (pos)
 
      size = pos - str;    else
 
      size = strlen(str) - 1; /* - 1 to get rid of \n */
 
    nb++;
 
    res = realloc(res, (nb + 1) * sizeof (char*));
 
    res[nb -1] = strndup(str,  size);
 
    str = pos + 1;
 
  }
 
  while (pos);
 
 
 
  res[nb] = 0;
 
 
 
  return res;
 
}
 
 
 
int is_same(const char* const s1, const char* const s2)
 
{
 
  char **t1, **t2;
 
  int ret = 0;
 
 
 
  t1 = get_word(s1);
 
  t2 = get_word(s2);
 
 
 
  if (t1 && t2)
 
  {
 
    char** tab1 = t1;
 
    char** tab2 = t2;
 
    int nb = 0;
 
    int size = 0;
 
 
 
    while (tab1 && *tab1)
 
    {
 
      tab2 = t2;
 
      while (tab2 && *tab2)
 
      {
 
	if (!strcmp(*tab1, *tab2))
 
	  nb++;
 
	tab2++;
 
      }      tab1++;
 
      size++;
 
    }
 
 
 
    ret = (nb >= size);
 
    free_tab(t1);
 
    free_tab(t2);
 
  }
 
  return ret;
 
}
 
 
 
char** compare_file(const char* filename1, const char* filename2)
 
{
 
  FILE *f, *f1;
 
  char s[MAX_SIZE], s1[MAX_SIZE];
 
  int a;
 
  char** res = NULL;
 
  int nb = 0;
 
 
 
  f = fopen(filename1, "r");
 
  f1 = fopen(filename2, "r");
 
  if (f && f1)
 
  {
 
    while (fgets(s, MAX_SIZE, f))
 
    {
 
      a = 0;
 
      rewind(f1);
 
      while (fgets(s1, MAX_SIZE, f1))
 
      {
 
	if (is_same(s, s1))
 
	{
 
	  a = 1;
 
	  break;
 
	}
 
      }
 
      if (!a)
 
      {
 
	nb++;
 
	res = realloc(res, (nb + 1) * sizeof (char*));
 
	res[nb - 1] = strndup(s, strlen(s) - 1); /* Get rid of the \n */
 
	res[nb] = 0;
 
      }
 
    }
 
    fclose(f);
 
    fclose(f1);
 
  }
 
  return res;
 
}
 
 
 
/*char** copy_tab(char** tab)
 
{
 
  char** res = NULL;
 
  int nb = 0;
 
 
 
  while (tab && *tab)
 
  {
 
    nb++;
 
    res = realloc(res, (nb + 1) * sizeof (char*));
 
    res[nb - 1] = strndup(*tab, strlen(*tab));
 
    res[nb] = 0;
 
    tab++;
 
  }
 
 
 
  return res;
 
}
*/
 
/*
char** compute_intersect(char** tab1, char** tab2)
 
{
 
  if (!tab2)
 
    return NULL;
 
  if (!tab1)
 
    return copy_tab(tab2);
 
 
 
 //  Ici finir de coder l'intersection
 
 
 
  return NULL;
 
}*/
 
 
 
void display_tab(char** tab)
 
{
 
  while (tab && *tab)
 
  {
 
    printf("%s\n", *tab);
 
    tab++;
 
  }
 
}
 
 
 
int main()
 
{
 
  char** res = NULL;
 
  //char** intersect = NULL;
 
  char input[32];
 
  int i;
 
 
 
  for (i = 1; i <= 3; i++)
 
  {
 
    sprintf(input,"f%d.txt",i);
 
    res = compare_file("f.txt",input);
 
    /* temp */
 
    printf("Comparing f.txt and %s:\n", input);
 
    display_tab(res);
 
    /* ! temp */
 
   // intersect = compute_intersect(intersect, res);
 
    free_tab(res);
 
  }
 
 
 
  printf("Final result:\n");
 
  //display_tab(intersect);
 
  //free_tab(intersect);
 
 
 
  return 0;
 
}

La compilation se passe bien mais lorsque je lance l'exécution alors je n'obtiens rien comme résultat d'affichage.

J'ai besoin de vos aides. je suis bloqué.

Si vous avez autres solutions plus rapides et meilleure que mienne pas de problème car je cherche la solution la plus rapide au niveau temps d'exécution.

Merci.

[siempre]

Bonjour,

J'ai eu le même problème: la compilation se passe bien mais l'exécution ne termine pas correctement.
Avec quel outil sous windows vous avez testé la solution ?

Je suis entrain de programmer avec visual studio 2008.
J'ai ajouté quelques affichages "printf" dans la fonction main et la fonction compare_file pour voir la source de d'erreur.

J'ai remarqué que le programme fait seulement une comparaison entre f.txt et f1.txt puis il exécute la fonction "compare_file" puis il ne retourne pas à la fonction "main" puisque il n'affiche pas l'instrcution:

printf("Comparing f.txt and %s:\n", input);

Voici le code auquel jai ajouté des "printf"

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
#include <stdio.h>
 
#include <stdlib.h>
 
#include <string.h>
 
 
 
#define MAX_SIZE 1024
 
 
 
char* strndup(const char *str, size_t n)
 
{
 
  char *ret = malloc((n+1) * sizeof (char));
 
 
 
  if (!ret)
 
    exit(0);  strncpy(ret, str, n);
 
  ret[n] = 0;
 
 
 
  return ret;
 
}
 
 
 
void free_tab(char** t)
 
{
 
  char** head = t;
 
 
 
  while (t && *t)
 
  {
 
    free(*t);
 
    t++;
 
 
 
  }
 
  free(head);
 
}
 
 
 
char** get_word(const char* str)
 
{
 
  char* pos = NULL;
 
  char** res = NULL;
 
  int nb = 0;
 
 
 
  do
 
  {
 
    int size = 0;
 
 
 
    pos = strchr(str, ' ');
 
    if (pos)
 
      size = pos - str;    else
 
      size = strlen(str) - 1; /* - 1 to get rid of \n */
 
    nb++;
 
    res = realloc(res, (nb + 1) * sizeof (char*));
 
    res[nb -1] = strndup(str,  size);
 
    str = pos + 1;
 
  }
 
  while (pos);
 
 
 
  res[nb] = 0;
 
 
 
  return res;
 
}
 
 
 
int is_same(const char* const s1, const char* const s2)
 
{
 
  char **t1, **t2;
 
  int ret = 0;
 
 
 
  t1 = get_word(s1);
 
  t2 = get_word(s2);
 
 
 
  if (t1 && t2)
 
  {
 
    char** tab1 = t1;
 
    char** tab2 = t2;
 
    int nb = 0;
 
    int size = 0;
 
 
 
    while (tab1 && *tab1)
 
    {
 
      tab2 = t2;
 
      while (tab2 && *tab2)
 
      {
 
	if (!strcmp(*tab1, *tab2))
 
	  nb++;
 
	tab2++;
 
      }      tab1++;
 
      size++;
 
    }
 
 
 
    ret = (nb >= size);
 
    free_tab(t1);
 
    free_tab(t2);
 
  }
 
 
 
  return ret;
 
}
 
 
 
char** compare_file(const char* filename1, const char* filename2)
 
{
 
  FILE *f, *f1;
 
  char s[MAX_SIZE], s1[MAX_SIZE];
 
  int a;
 
  char** res = NULL;
 
  int nb = 0;
 
 
 
  f = fopen(filename1, "r");
 
  f1 = fopen(filename2, "r");
 
  if (f && f1)
 
  {
 
    while (fgets(s, MAX_SIZE, f))
 
    {
         printf("s=%s\n",s);
      a = 0;
 
      rewind(f1);
 
      while (fgets(s1, MAX_SIZE, f1))
 
      {
 printf("s1=%s\n",s1);
	if (is_same(s, s1))
 
	{
 printf("eagle=%s\n",s);
	  a = 1;
 
	  break;
 
	}
 
      }
 
      if (!a)
 
      {
 printf("non egale=%s\n",s);
	nb++;
 
	res = realloc(res, (nb + 1) * sizeof (char*));
 
	res[nb - 1] = strndup(s, strlen(s) - 1); /* Get rid of the \n */
 
	res[nb] = 0;
 
      }
 
    }
 
    fclose(f);
 
    fclose(f1);
 
  }
 
 
 
  return res;
 
}
 
 
 
char** copy_tab(char** tab)
 
{
 
  char** res = NULL;
 
  int nb = 0;
 
 
 
  while (tab && *tab)
 
  {
 
    nb++;
 
    res = realloc(res, (nb + 1) * sizeof (char*));
 
    res[nb - 1] = strndup(*tab, strlen(*tab));
 
    res[nb] = 0;
 
    tab++;
 
  } 
 
 
 
  return res;
 
}
 
 
 
char** compute_intersect(char** tab1, char** tab2)
 
{
 
  if (!tab2)
 
    return NULL;
 
  if (!tab1)
 
    return copy_tab(tab2);
 
 
 
  /* Ici finir de coder l'intersection */
 
 
 
  return NULL;
 
}
 
 
 
void display_tab(char** tab)
 
{
 
  while (tab && *tab)
 
  {
 
    printf("%s\n", *tab);
 
    tab++;
 
  }
 
}
 
 
 
int main()
 
{
 
  char** res = NULL;
 
  char** intersect = NULL;
 
  char input[32];
 
  int i;
 
 
 
  for (i = 1; i <= 3; i++)
 
  {
  printf("%d\n",i);
    sprintf(input,"f%d.txt",i);
    printf("%s\n",input);
    res = compare_file("f.txt",input);
 
    /* temp */
 
    printf("Comparing f.txt and %s:\n", input);
 
    display_tab(res);
 
    /* ! temp */
 
   // intersect = compute_intersect(intersect, res);
 
    free_tab(res);
 
  }
 
 
 
  printf("Final result:\n");
 
  display_tab(intersect);
 
  free_tab(intersect);
 
 
 
  return 0;
 
}

J'obtiens après la compilation et l'exécution l'affichage suivant:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
1
f1.txt
s=a b
 
s1=a
 
s1=d a
 
s1=c a
 
s1=b c a
retour=a b
 
s=a c
 
s1=a
 
s1=d a
 
s1=c a
 
eagle=a c
 
s=a d
 
s1=a
 
s1=d a
 
eagle=a d
 
s=b c
 
s1=a
 
s1=d a
 
s1=c a
 
s1=b c a
 eagle=b c
 
s=b d
 
s1=a
 
s1=d a
 
s1=c a
 
s1=b c a
retour=b d
 
s=c d
 
s1=a
 
s1=d a
 
s1=c a
 
s1=b c a
retour=c d
 
s=a b c
 
s1=a
 
s1=d a
 
s1=c a
 
s1=b c a
retour=a b c
 
s=a b d
 
s1=a
 
s1=d a
 
s1=c a
 
s1=b c a
retour=a b d
 
s=b c d
 
s1=a
 
s1=d a
 
s1=c a
 
s1=b c a
retour=b c d
 
s=a c d
 
s1=a
 
s1=d a
 
s1=c a
 
s1=b c a
retour=a c d
 
s=a b c d
s1=a
 
 
Process returned -1073741819 <0 * C0000005>
Press any key to continue.
 
Une exception win 32 non gérée  s'est produite dans comparaison .exe

De plus, j'ai testé la solution avec code blocks alors j'obtiens le même problème de l'exécution:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
1
f1.txt
s=a b
 
s1=a
 
s1=d a
 
s1=c a
 
s1=b c a
retour=a b
 
s=a c
 
s1=a
 
s1=d a
 
s1=c a
 
eagle=a c
 
s=a d
 
s1=a
 
s1=d a
 
eagle=a d
 
s=b c
 
s1=a
 
s1=d a
 
s1=c a
 
s1=b c a
 eagle=b c
 
s=b d
 
s1=a
 
s1=d a
 
s1=c a
 
s1=b c a
retour=b d
 
s=c d
 
s1=a
 
s1=d a
 
s1=c a
 
s1=b c a
retour=c d
 
s=a b c
 
s1=a
 
s1=d a
 
s1=c a
 
s1=b c a
retour=a b c
 
s=a b d
 
s1=a
 
s1=d a
 
s1=c a
 
s1=b c a
retour=a b d
 
s=b c d
 
s1=a
 
s1=d a
 
s1=c a
 
s1=b c a
retour=b c d
 
s=a c d
 
s1=a
 
s1=d a
 
s1=c a
 
s1=b c a
retour=a c d
 
s=a b c d
s1=a
 
 
Process returned -1073741819 <0 * C0000005>
Press any key to continue.

Je suis bloquée.
J'ai besoin de vos aides pour savoir la source de ce problème de l'exécution.

Merci.

[ram-0000]

Si tu utilises Visual Studio, tu peux peut être utiliser son debugger. Il est très pratique et la recherche de problèmes est plus rapide avec un debugger qu'avec des printf() un peu partout dans le code.

[siempre]

Bonjour,

Comment utiliser le debugger de visual sudio 2008 ?

Merci.