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.

[ram-0000]

trouvé dans la section des tutoriels de DVP : Utiliser efficacement le débogueur de Visual Studio

[siempre]

J'ai utilisé ledebugger de visual sudio 2008.
Voici le résultat:

Exception non gérée à 0*1026fb89(msvcr90d.dll) dans comparaison .exe:
0*C0000005 : violation d'accées mlors de l'écriture à l'emplacement 0*0033a000.

De plus, à coté de la fenetre main il y a une apparition d'une autre fenetre strncpy.asm

Voici l'affichage de la sortie de debugeur:

'comparaison.exe' : Chargé 'C:\comparaison\Debug\comparaison.exe', Les symboles ont été chargés.
'comparaison.exe' : Chargé 'C:\WINDOWS\system32\ntdll.dll'
'comparaison.exe' : Chargé 'C:\WINDOWS\system32\kernel32.dll'
'comparaison.exe' : Chargé 'C:\WINDOWS\WinSxS\x86_Microsoft.VC90.DebugCRT_1fc8b3b9a1e18e3b_9.0.21022.8_x-ww_597c3456\msvcr90d.dll', Les symboles ont été chargés.
'comparaison.exe' : Chargé 'C:\Program Files\SuperCopier2\SC2Hook.dll', Le fichier binaire n'a pas été généré avec les informations de débogage.
'comparaison.exe' : Chargé 'C:\WINDOWS\system32\user32.dll'
'comparaison.exe' : Chargé 'C:\WINDOWS\system32\gdi32.dll'
'comparaison.exe' : Chargé 'C:\WINDOWS\system32\advapi32.dll'
'comparaison.exe' : Chargé 'C:\WINDOWS\system32\rpcrt4.dll'
'comparaison.exe' : Chargé 'C:\WINDOWS\system32\oleaut32.dll'
'comparaison.exe' : Chargé 'C:\WINDOWS\system32\msvcrt.dll'
'comparaison.exe' : Chargé 'C:\WINDOWS\system32\ole32.dll'
'comparaison.exe' : Chargé 'C:\WINDOWS\system32\imm32.dll'
'comparaison.exe' : Chargé 'C:\WINDOWS\system32\lpk.dll'
'comparaison.exe' : Chargé 'C:\WINDOWS\system32\usp10.dll'
Exception de première chance à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception non gérée à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception de première chance à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception non gérée à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception de première chance à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception non gérée à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception de première chance à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception non gérée à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception de première chance à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception non gérée à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception de première chance à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception non gérée à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception de première chance à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception non gérée à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception de première chance à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception non gérée à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception de première chance à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception non gérée à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception de première chance à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception non gérée à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception de première chance à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception non gérée à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception de première chance à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception non gérée à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception de première chance à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception non gérée à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception de première chance à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception non gérée à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception de première chance à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception non gérée à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception de première chance à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception non gérée à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception de première chance à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception non gérée à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception de première chance à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.
Exception non gérée à 0x1026fb89 (msvcr90d.dll) dans comparaison.exe : 0xC0000005: Violation d'accès lors de l'écriture à l'emplacement 0x0033a000.



De plus j'ai utilisé le deboggeur de code blocks alors il me donne :

Building to ensure sources are up-to-date
Build succeeded
Selecting target:
Debug
Adding source dir: C:\between\
Adding source dir: C:\between\
Adding file: bin\Debug\between.exe
Starting debugger:
done
Registered new type: wxString
Registered new type: STL String
Registered new type: STL Vector
Setting breakpoints
Debugger name and version: GNU gdb 6.7.50.20071127
Child process PID: 3676
Program received signal SIGSEGV, Segmentation fault.
In strncpy () (C:\WINDOWS\system32\msvcrt.dll)


A mon avis, les deux debogeurs indiquent que le problème est dans la foncntion strncpy ()

Que pensez vous ? et comment je ce problème va être résolu.

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

Merci.

[ram-0000]

• tu poses un point d'arrêt sur la ligne où il y a l'appel à strncpy
• lorsque le programme s'arrête, tu regardes les paramètres qui vont être passés à strncpy
• et tu essayes de comprendre pourquoi ils sont mauvais

[siempre]

Bonsoir,

J'ai posé un point d'arrêt sur la ligne où il y a l'appel à strncpy dans l'ancien version
lorsque le programme s'arrête, j'ai regardé les paramètres qui vont être passés à strncpy.
Voici ces valeurs:
Nom Valeur Type
n 1 unsigned int
ret 0x00339210 "ÍÍýýýý««««««««îþ" char *
str 0x0012fa1c "a b" const char *

Signifie quoi ces valeurs ?

J'ai essayé de faire ma propre strcpy que je le nomme my_strncpy
Voici mon esai.

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
 
char* my_strncpy(char* to, const char* from, size_t size)
 
{
 
  char* head = to;
 
 
 
  while (from && *from && size > 0)
 
  {
 
    *to = * from;
 
    to++;
 
    from++;
 
    --size;
 
  }
 
  *to = 0;
 
 
 
  return head;
 
}

Alors la compilation se passe bien mais l'exécution ne passe pas bien et j'obtiens le message suivant:
Debug Error !

Program: c:\comparaison\debug\comparaison.exe

HEAP CORRUPTION DETECTED : before Normal Block (#408) at 0*00338108.
CRT detected that the last application wrote to memory before start of heap buffer.

S'il vous plait, j'ai besoin de votre aide.

Merci.

[Médinoc]

Avec une taille de 1, es-tu sûr qu'il n'y a pas un problème quelque part?
Montre-nous l'appel à strncpy() en question.

[siempre]

Bonjour,

Avec une taille de 1, es-tu sûr qu'il n'y a pas un problème quelque part?
Montre-nous l'appel à strncpy() en question.

je ne comprends pas votre question.

Pouvez vous m'explique encore ?


Merci.

[nicolas.sitbon]

Tu fais un off-by-one dans my_strncpy(), de plus, plutôt que de réinventer la roue, ta fonction semble vouloir imiter le fonctionnement de strlcpy(), autant se servir à la source:

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
/*	$OpenBSD: strlcpy.c,v 1.11 2006/05/05 15:27:38 millert Exp $	*/
 
/*
 * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#include <sys/types.h>
#include <string.h>
 
/*
 * Copy src to string dst of size siz.  At most siz-1 characters
 * will be copied.  Always NUL terminates (unless siz == 0).
 * Returns strlen(src); if retval >= siz, truncation occurred.
 */
size_t
strlcpy(char *dst, const char *src, size_t siz)
{
	char *d = dst;
	const char *s = src;
	size_t n = siz;
 
	/* Copy as many bytes as will fit */
	if (n != 0) {
		while (--n != 0) {
			if ((*d++ = *s++) == '\0')
				break;
		}
	}
 
	/* Not enough room in dst, add NUL and traverse rest of src */
	if (n == 0) {
		if (siz != 0)
			*d = '\0';		/* NUL-terminate dst */
		while (*s++)
			;
	}
 
	return(s - src - 1);	/* count does not include NUL */
}

[siempre]

Bonjour,

Tu fais un off-by-one dans my_strncpy(), de plus, plutôt que de réinventer la roue, ta fonction semble vouloir imiter le fonctionnement de strlcpy(), autant se servir à la source:

Je ne comprends pas votre réponse.
pouvez vous m'expliquer encore de plus ?

Le code suivant est écrit avec quel compilateur et avec quel système d'exploitation ?
Ce code permet de faire quoi ?

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
/*	$OpenBSD: strlcpy.c,v 1.11 2006/05/05 15:27:38 millert Exp $	*/
 
/*
 * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#include <sys/types.h>
#include <string.h>
 
/*
 * Copy src to string dst of size siz.  At most siz-1 characters
 * will be copied.  Always NUL terminates (unless siz == 0).
 * Returns strlen(src); if retval >= siz, truncation occurred.
 */
size_t
strlcpy(char *dst, const char *src, size_t siz)
{
	char *d = dst;
	const char *s = src;
	size_t n = siz;
 
	/* Copy as many bytes as will fit */
	if (n != 0) {
		while (--n != 0) {
			if ((*d++ = *s++) == '\0')
				break;
		}
	}
 
	/* Not enough room in dst, add NUL and traverse rest of src */
	if (n == 0) {
		if (siz != 0)
			*d = '\0';		/* NUL-terminate dst */
		while (*s++)
			;
	}
 
	return(s - src - 1);	/* count does not include NUL */
}

j'ai remarqué que le programme sort lorsque il arrive à lire la dernière ligne "a b c d" de fichier "f.txt" si j'utilise la fonction standard strncpy().
donc j'ai supprimé cette ligne "a b c d" du fichier "f.txt"
et j'ai lancé l'exécution alors j'ai cet affichage:

Comparing f.txt and f1.txt:
a b
b d
c d
a b c
a b d
b c d
a c d
Comparing f.txt and f2.txt:
a c
b d
a b c
a b d
b c d
a c d

Comparing f.txt and f3.txt:
b d
c d
a b c
a b d
b c d
a c d
Final result:

Mais, cet affichage n'est pas le vrai résultat.

- Pourquoi lorsque je supprime la dernière ligne "a b c d" du fichier "f.txt" alors l'exécution se passe ?

J'ai besoin de vos aides.

Merci.

[nicolas.sitbon]

Je ne comprends pas votre réponse.
pouvez vous m'expliquer encore de plus ?

Un off-by-one signifie que tu écris plus de donnés qu'il n'y a de place dans ton tableau, en l'occurrence, tu écris un byte de trop, donc comportement indéterminé.

Le code suivant est écrit avec quel compilateur et avec quel système d'exploitation ?

On écrit pas un code avec un compilateur, mais avec un éditeur et je ne vois pas ce que ça change.

Ce code permet de faire quoi ?

Code :

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

1
2
3
4
5
6
 
/*
 * Copy src to string dst of size siz.  At most siz-1 characters
 * will be copied.  Always NUL terminates (unless siz == 0).
 * Returns strlen(src); if retval >= siz, truncation occurred.
 */

ça serait bien de lire les réponses en entière en prenant le temps de les comprendre.

[siempre]

Bonjour,
J'ai fait mon programme C suivant sous windows avec Visual studio 2008.
Supposons que on a 4 fichiers textes :
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

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

Ce programme permet d'afficher le résultat de comparaison entre :
- f.txt et f1.txt
- f.txt et f2.txt
- f.txt et f3.txt

J'ai déjà décrit auparavant la procédure de comparaison entre deux fichiers qui doit respecter les deux conditions :
l'ignorance de l'ordre entre les mots et l'inclusion.

Voici le programme:

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
#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;
 
}
 
 
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);
 
 
    printf("Comparing f.txt and %s:\n", input);
 
    display_tab(res);
 
    free_tab(res);
 
  }
  return 0;
 
}

Après la compilation et l'exécution, j'obtiens l'affichage suivant:

Comparing f.txt and f1.txt:
a b
b d
c d
a b c
a b d
b c d
a c d
a b c d
Comparing f.txt and f2.txt:
a c
b d
a b c
a b d
b c d
a c d
a b c d

Comparing f.txt and f3.txt:
b d
c d
a b c
a b d
b c d
a c d
a b c d
Final result:

Mais, le résultat souhaité est :

b d
c d
a b d
b c d
a c d
a b c d
Comparing f.txt and f2.txt:
b d
a b d
b c d
a c d
a b c d
Comparing f.txt and f3.txt:
b d
c d
a b d
b c d
a c d
a b c d

J'ai révisé mon code beaucoup des fois mais je ne trouve pas pourquoi je n'obtiens pas le résultat souhaité.

Vous avez le code et les fichiers textes. Pouvez vous tester ce code et me dire que est ce il affiche chez vous ?

Je tiens compte sur vos aides.

Merci.

[siempre]

Bonjour,

vous dites:

Tu fais un off-by-one dans my_strncpy(), de plus, plutôt que de réinventer la roue, ta fonction semble vouloir imiter le fonctionnement de strlcpy(), autant se servir à la source:

J'ai mis le code de la fonction strlcpy() sue vous proposez dans mon programme
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
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
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
 
#include <stdio.h>
#include <stdlib.h> 
#include <string.h>
#include <sys/types.h>
 
#define MAX_SIZE 1024
 
 
strlcpy(char *dst, const char *src, size_t siz)
{
	char *d = dst;
	const char *s = src;
	size_t n = siz;
 
	/* Copy as many bytes as will fit */
	if (n != 0) {
		while (--n != 0) {
			if ((*d++ = *s++) == '\0')
				break;
		}
	}
 
	/* Not enough room in dst, add NUL and traverse rest of src */
	if (n == 0) {
		if (siz != 0)
			*d = '\0';		/* NUL-terminate dst */
		while (*s++)
			;
	}
 
	return(s - src - 1);	/* count does not include NUL */
}
 
char* strndup(const char *str, size_t n)
 
{
 
  char *ret = malloc((n+1) * sizeof (char));
 
 
 
  if (!ret)
 
    exit(0); 
 
 strlcpy(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;
 
}

Après la compilation et l'exécution, j'obtiens:

Comparing f.txt and f1.txt:
Comparing f.txt and f2.txt:
Comparing f.txt and f3.txt:
Final result:

Appuyez sur une touche pour continuer...

Mais, le résultat souhaité est :

Comparing f.txt and f1.txt:
b d
c d
a b d
b c d
a c d
a b c d
Comparing f.txt and f2.txt:
b d
a b d
b c d
a c d
a b c d
Comparing f.txt and f3.txt:
b d
c d
a b d
b c d
a c d
a b c d

Que proposez vous ?

Merci.

[siempre]

Bonjour,
Je ne sais pas pourquoi l'exécution d'un programme se diffère d'une personne à l'autre malgré qu'il s'agit de même programme C qui contient des fonctions standards et des instructions comprises par un compilateur C.

J'ai besoin de vos réponses.

S'il vous plait, j'ai besoin de vos aides pour que je puisse trouver une solution à mon problème.

Merci.

[gl]

Je ne sais pas pourquoi l'exécution d'un programme se diffère d'une personne à l'autre malgré qu'il s'agit de même programme C qui contient des fonctions standards et des instructions comprises par un compilateur C.

A priori parce qu'il y a un comportement indéfini quelque part ou une mauvaise gestion d'erreur.

S'il vous plait, j'ai besoin de vos aides pour que je puisse trouver une solution à mon problème.

Je n'ai pas regarder en détail mais j'ai déjà vu :

• Une mauvaise utilisation de realloc() qui peut conduire dans certains cas à une fuite mémoire. Je t'invite à aller voir les discussions à ce sujet, par exemple celle-ci.
• En cas d'erreur d'ouverture de filename2, le fichier filename n'est pas fermé.
• Dans le fonction get_word(), tu considères que la chaîne passée en paramètre est forcément terminè par un \n.Or vu le traitement, ce n'est pas forcément le cas (si la taille de la ligne est supérieure à MAX_SIZE ou sur la dernière ligne du fichier si elle n'est pas terminée par un retour chariot).

[siempre]

Bonjour,

Si vous voulez je vous explique encore le problème.
Quelles sont les modifications à faire pour aboutir à une solution ?
Si vous avez autre solution à ce problème alors pas de problème...
Je suis bloquée et j'ai besoin de vos aides.

Merci.