Discussion :

[simplyc]

bonjour
en fait je suis en train de faire un exo que me demande de rajouté des valeurs a un tableau dynamique et quand le tableau sera remplie je demande encore de mémoire a l aide de realloc
je vous montre exactement c est que j avais fais
ici j ai initialisé mon tableau ,NB est la taille qui vaut 10 ,RIEN est un macro qui vaut 0

Code :

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

1
2
3
4
5
6
7
8
9
void inittab(int **tab)
{
int i=0;
*tab=(int*)malloc(sizeof(int)*NB);
for(;i<NB;i++)
{
*(tab+i)=RIEN;
}
}

ici j ai enfilé mon tableau en passant en parametre le valeur et le tableau ,tete est un pointeur qui pointe a la premiere case de tableau ,a chaque fois que j enfile ,tete s i ncremente jusqu a la fin

Code :

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

1
2
3
4
5
6
7
8
9
void enfile(int va,int *tab)
{
if((cases<NB)&&(tete<=tab+NB))
{
*(tab+cases)=va;
tete++;
cases++;
va++;
}

jusqua la l affichage est correcte

le probleme quand j atteint la derniere case de tableau,ici l exercice me demande de faire une realocation de mémoire de coup j ai fais comme ca

Code :

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

1
2
else//quand je dépasse la limite
tab=realloc(tab,NB*sizeof(int));

ici j ai vu des trucs bizarre
0 0 0 0 0
2 0 0 0 0
2 3 0 0 0
2 3 4 0 0
2 3 4 5 0
2 3 4 5 6
*** glibc detected *** ./tp2: realloc(): invalid pointer: 0xbf991d2c ***
======= Backtrace: =========
/lib/i386-linux-gnu/libc.so.6(+0x6b961)[0x7f4961]
/lib/i386-linux-gnu/libc.so.6(realloc+0x2ad)[0x7f973d]
/lib/i386-linux-gnu/libc.so.6(realloc+0x2c5)[0x7f9755]
./tp2[0x8048536]
./tp2[0x8048633]
/lib/i386-linux-gnu/libc.so.6(__libc_start_main+0xe7)[0x79fe37]
./tp2[0x80483c1]
======= Memory map: ========
00110000-0012a000 r-xp 00000000 08:05 7603037 /lib/i386-linux-gnu/libgcc_s.so.1
0012a000-0012b000 r--p 00019000 08:05 7603037 /lib/i386-linux-gnu/libgcc_s.so.1
0012b000-0012c000 rw-p 0001a000 08:05 7603037 /lib/i386-linux-gnu/libgcc_s.so.1
0014f000-00150000 r-xp 00000000 00:00 0 [vdso]
004e0000-004fc000 r-xp 00000000 08:05 7602996 /lib/i386-linux-gnu/ld-2.13.so
004fc000-004fd000 r--p 0001b000 08:05 7602996 /lib/i386-linux-gnu/ld-2.13.so
004fd000-004fe000 rw-p 0001c000 08:05 7602996 /lib/i386-linux-gnu/ld-2.13.so
00789000-008e3000 r-xp 00000000 08:05 7603009 /lib/i386-linux-gnu/libc-2.13.so
008e3000-008e4000 ---p 0015a000 08:05 7603009 /lib/i386-linux-gnu/libc-2.13.so
008e4000-008e6000 r--p 0015a000 08:05 7603009 /lib/i386-linux-gnu/libc-2.13.so
008e6000-008e7000 rw-p 0015c000 08:05 7603009 /lib/i386-linux-gnu/libc-2.13.so
008e7000-008ea000 rw-p 00000000 00:00 0
08048000-08049000 r-xp 00000000 08:05 4068617 /home/chiheb/Documents/L3/Cavancé/tp2/tp2
aborted



merci de m avoir aidé pour resoudre cette probleme

[diogene]

- inittab() : ceci est faux :

Code :

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

*(tab+i)=RIEN;

tab est un int** pas un int *. Tu as la malchance d'avoir size(int) == sizeof(int*) ce qui fait que ça semble marcher.
Correction :

Code :

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

1
2
3
*(*tab+i)=RIEN; 
// ou
(*tab)[i]=RIEN;

- inittab() : on doit tester que le retour de malloc n'est pas NULL

Code :

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

1
2
3
4
5
6
7
void inittab(int **tab)
{
  int i;
  *tab = malloc(sizeof(int)*NB);
  if(*tab != NULL)
     for(i=0;i<NB;i++) (*tab)[i]=RIEN;
}

- Ta fonction enfile() ne nous apprend rien puisqu'elle invoque des variables globales (tete, cases). Il faut prohiber les variables globales sauf absolue nécessité car ce sont des pestes pour plusieurs raisons L'une d'elles est qu'elles empêchent les fonctions d'être des portions de code autonome compréhensibles indépendamment du reste du programme.

- le va++ dans enfile() ne sert à rien

- le realloc() peut échouer et retourner NULL. Dans ton code, la mémoire précédemment allouée devient irrécupérable.
La schéma typique d'utilisation est :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
   int * p =realloc(tab,NB*sizeof(int));
   if(p != NULL) 
   {
      tab = p;
....
   }
   else  // échec de réallocation. Prendre les dispositions qui s'imposent
   {  
      free(tab); // par exemple récupérer la mémoire allouée précédemment
....
   }

- pour le plantage sur le realloc(), il faut montrer plus amplement le code où il intervient.

[simplyc]

- inittab() : ceci est faux :

Code :

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

*(tab+i)=RIEN;

tab est un int** pas un int *. Tu as la malchance d'avoir size(int) == sizeof(int*) ce qui fait que ça semble marcher.
Correction :

Code :

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

1
2
3
*(*tab+i)=RIEN; 
// ou
(*tab)[i]=RIEN;

- inittab() : on doit tester que le retour de malloc n'est pas NULL

Code :

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

1
2
3
4
5
6
7
void inittab(int **tab)
{
  int i;
  *tab = malloc(sizeof(int)*NB);
  if(*tab != NULL)
     for(i=0;i<NB;i++) (*tab)[i]=RIEN;
}

- Ta fonction enfile() ne nous apprend rien puisqu'elle invoque des variables globales (tete, cases). Il faut prohiber les variables globales sauf absolue nécessité car ce sont des pestes pour plusieurs raisons L'une d'elles est qu'elles empêchent les fonctions d'être des portions de code autonome compréhensibles indépendamment du reste du programme.

- le va++ dans enfile() ne sert à rien

- le realloc() peut échouer et retourner NULL. Dans ton code, la mémoire précédemment allouée devient irrécupérable.
La schéma typique d'utilisation est :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
   int * p =realloc(tab,NB*sizeof(int));
   if(p != NULL) 
   {
      tab = p;
....
   }
   else  // échec de réallocation. Prendre les dispositions qui s'imposent
   {  
      free(tab); // par exemple récupérer la mémoire allouée précédemment
....
   }

- pour le plantage sur le realloc(), il faut montrer plus amplement le code où il intervient.

merci pour votr intervention
j ai changé la fonction inittab() l affichage auusi est changé,je vois l adresse mémoire maintenant
oui c est vrai va elle sert a rien,par contre pour les variables globales que j ai utulisé tete et cases ,je suis d accord avec toi c est pas bien de l utulisé comme ca, parce que c est pas propre mais franchement c est la seule solution que j ai trouvé parce que je sais pas combien de fois je dois enfilé ou defilé c est pour ca a chaque fois j appele la fonction enfilé le pointeur tete il s incremente et la cases aussi
aprés j ai pas encore compris comment je peux realloué la mémoire pour que je puisse donné des valeurs
voila le code avec la fonction defile que pas utulie pour l instant

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
#include<stdio.h>
#include<stdlib.h>
#define NB 5
#define RIEN 0
int que=0;
int va=4;
int cases=0;
int vals=0;
int tab[NB];
int *tete=tab;
void inittab(int **tab)
{
int i=0;
*tab=(int*)malloc(sizeof(int)*NB);
for(;i<NB;i++)
{
*(tab+i)=RIEN;
}
}
void afficher(int *tab)
{
int i;
for(i=0;i<NB;i++)
{
printf("%d ",tab[i]);
}
printf("\n");
}
void enfile(int va,int *tab)
{
if((cases<NB)&&(tete<=tab+NB))
{
*(tab+cases)=va;
tete++;
cases++;
 
}
//else
//tab=realloc(tab,NB*sizeof(int));
 
}
void defile(int *tab)
{
*(tab+que)=RIEN;
que++;
}
main()
{
 
int tab[NB];
inittab(&tab);
afficher(tab);
enfile(2,tab);
afficher(tab);
enfile(3,tab);
afficher(tab);
enfile(4,tab);
afficher(tab);
enfile(5,tab);
afficher(tab);
enfile(6,tab);
afficher(tab);
enfile(7,tab);
afficher(tab);
defile(tab);
afficher(tab);
//defile(tab);
afficher(tab);
}

merci de m avoir bien m éxpliquer s il vous plais

[Sve@r]

merci pour votr intervention
j ai changé la fonction inittab() l affichage auusi est changé,je vois l adresse mémoire maintenant
oui c est vrai va elle sert a rien,par contre pour les variables globales que j ai utulisé tete et cases ,je suis d accord avec toi c est pas bien de l utulisé comme ca, parce que c est pas propre mais franchement c est la seule solution que j ai trouvé parce que je sais pas combien de fois je dois enfilé ou defilé c est pour ca a chaque fois j appele la fonction enfilé le pointeur tete il s incremente et la cases aussi
aprés j ai pas encore compris comment je peux realloué la mémoire pour que je puisse donné des valeurs
voila le code avec la fonction defile que pas utulie pour l instant

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
#include<stdio.h>
#include<stdlib.h>
#define NB 5
#define RIEN 0
int que=0;
int va=4;
int cases=0;
int vals=0;
int tab[NB];
int *tete=tab;
void inittab(int **tab)
{
int i=0;
*tab=(int*)malloc(sizeof(int)*NB);
for(;i<NB;i++)
{
*(tab+i)=RIEN;
}
}
void afficher(int *tab)
{
int i;
for(i=0;i<NB;i++)
{
printf("%d ",tab[i]);
}
printf("\n");
}
void enfile(int va,int *tab)
{
if((cases<NB)&&(tete<=tab+NB))
{
*(tab+cases)=va;
tete++;
cases++;
 
}
//else
//tab=realloc(tab,NB*sizeof(int));
 
}
void defile(int *tab)
{
*(tab+que)=RIEN;
que++;
}
main()
{
 
int tab[NB];
inittab(&tab);
afficher(tab);
enfile(2,tab);
afficher(tab);
enfile(3,tab);
afficher(tab);
enfile(4,tab);
afficher(tab);
enfile(5,tab);
afficher(tab);
enfile(6,tab);
afficher(tab);
enfile(7,tab);
afficher(tab);
defile(tab);
afficher(tab);
//defile(tab);
afficher(tab);
}

merci de m avoir bien m éxpliquer s il vous plais

Salut
Ton code est aussi horrible que ton orthographe !!! Tu n'as jamais appris à indenter???

Alors
1) on te dit que les variables globales c'est mal. Si tu ne sais pas comment t'en passer ben le plus simple est de créer une structure permettant de gérer ta pile et qui contiendra toutes les variables utiles à la pile. Ensuite, ben tes fonctions reçoivent la structure et ont donc accès aux variables qui y sont liées

2) quand tu écris (2 fois d'ailleurs) int tab[NB] tu as défini un tableau figé en mémoire. Tu ne peux plus le réallouer. Pour qu'il puisse être réalloué par realloc, il eut fallu d'abord l'allouer par malloc

3) RIEN est avantageusement remplaçable par NULL qui est standard

Code c :

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
#define PILE_ALLOC (100)
#define PILE_ERREURALLOC (0x01)
#define PILE_ERREURVIDE  (0x02)
 
typedef struct {
    int *tab;
    size_t taille_allouee;
    size_t taille_utilisee;
    int error;
} t_pile;
 
void initpile(t_pile *pile)
{
    pile->tab=NULL;
    pile->taille_allouee=0;
    pile->taille_utilisee=0;
    pile->error=0;
}
 
char *empile(t_pile *pile, int val)
{
    if (pile->taille_utilisee == pile->taille_allouee)
    {
        char *tmp;
        pile->taille_utilisee+=PILE_ALLOC;
        tmp=realloc(pile->tab, pile->taille_utilisee * sizeof(int));
        if (tmp == NULL)
        {
             pile->error=PILE_ERREURALLOC;
             return NULL;
        }
 
        pile->tab=tmp;
    }
 
    pile->tab[pile->taille_utilisee]=val;
    pile->taille_utilisee++;
    return pile->tab;
}
 
int depile(t_pile *pile)
{
    if (pile->taille_utilisee == 0)
    {
         pile->error=PILE_ERREURVIDE;
         return -1;
    }
    pile->taille_utilisee--;
 
    return pile->tab[pile->taille_utilisee];
}
 
void liberepile(t_pile *pile)
{
     if (pile->tab)
        free(pile->tab);
}
 
int main()
{
    t_pile pile;
    int val;
 
    initpile(&pile);
 
    if (empile(&pile, 5) == NULL)
    {
         printf("Erreur %d sur empile 5\n", pile.error);
         liberepile(&pile);
    }
 
    if (empile(&pile, 6) == NULL)
    {
         printf("Erreur %d sur empile 6\n", pile.error);
         liberepile(&pile);
    }
 
     if ((val=depile(&pile)) == -1 && pile->error == PILE_ERREURVIDE)
     {
          printf("Erreur pile vide\n");
     }
     else
     {
          printf("Valeur=%d\n", val);
     }
 
     if ((val=depile(&pile)) == -1 && pile->error == PILE_ERREURVIDE)
     {
          printf("Erreur pile vide\n");
     }
     else
     {
          printf("Valeur=%d\n", val);
     }
 
     if ((val=depile(&pile)) == -1 && pile->error == PILE_ERREURVIDE)
     {
          printf("Erreur pile vide\n");
     }
     else
     {
          printf("Valeur=%d\n", val);
     }
 
     liberepile(&pile);
}

[simplyc]

Salut
Ton code est aussi horrible que ton orthographe !!! Tu n'as jamais appris à indenter???

Alors
1) on te dit que les variables globales c'est mal. Si tu ne sais pas comment t'en passer ben le plus simple est de créer une structure permettant de gérer ta pile et qui contiendra toutes les variables utiles à la pile. Ensuite, ben tes fonctions reçoivent la structure et ont donc accès aux variables qui y sont liées

2) quand tu écris (2 fois d'ailleurs) int tab[NB] tu as défini un tableau figé en mémoire. Tu ne peux plus le réallouer. Pour qu'il puisse être réalloué par realloc, il eut fallu d'abord l'allouer par malloc

3) RIEN est avantageusement remplaçable par NULL qui est standard

Code c :

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
#define PILE_ALLOC (100)
#define PILE_ERREURALLOC (0x01)
#define PILE_ERREURVIDE  (0x02)
 
typedef struct {
    int *tab;
    size_t taille_allouee;
    size_t taille_utilisee;
    int error;
} t_pile;
 
void initpile(t_pile *pile)
{
    pile->tab=NULL;
    pile->taille_allouee=0;
    pile->taille_utilisee=0;
    pile->error=0;
}
 
char *empile(t_pile *pile, int val)
{
    if (pile->taille_utilisee == pile->taille_allouee)
    {
        char *tmp;
        pile->taille_utilisee+=PILE_ALLOC;
        tmp=realloc(pile->tab, pile->taille_utilisee * sizeof(int));
        if (tmp == NULL)
        {
             pile->error=PILE_ERREURALLOC;
             return NULL;
        }
 
        pile->tab=tmp;
    }
 
    pile->tab[pile->taille_utilisee]=val;
    pile->taille_utilisee++;
    return pile->tab;
}
 
int depile(t_pile *pile)
{
    if (pile->taille_utilisee == 0)
    {
         pile->error=PILE_ERREURVIDE;
         return -1;
    }
    pile->taille_utilisee--;
 
    return pile->tab[pile->taille_utilisee];
}
 
void liberepile(t_pile *pile)
{
     if (pile->tab)
        free(pile->tab);
}
 
int main()
{
    t_pile pile;
    int val;
 
    initpile(&pile);
 
    if (empile(&pile, 5) == NULL)
    {
         printf("Erreur %d sur empile 5\n", pile.error);
         liberepile(&pile);
    }
 
    if (empile(&pile, 6) == NULL)
    {
         printf("Erreur %d sur empile 6\n", pile.error);
         liberepile(&pile);
    }
 
     if ((val=depile(&pile)) == -1 && pile->error == PILE_ERREURVIDE)
     {
          printf("Erreur pile vide\n");
     }
     else
     {
          printf("Valeur=%d\n", val);
     }
 
     if ((val=depile(&pile)) == -1 && pile->error == PILE_ERREURVIDE)
     {
          printf("Erreur pile vide\n");
     }
     else
     {
          printf("Valeur=%d\n", val);
     }
 
     if ((val=depile(&pile)) == -1 && pile->error == PILE_ERREURVIDE)
     {
          printf("Erreur pile vide\n");
     }
     else
     {
          printf("Valeur=%d\n", val);
     }
 
     liberepile(&pile);
}

je sais pas pourqoi a chaque fois que je pose une question ici,je retrouve des reponse comliqué,
j ai trouvé le probleme,regardé c est pas plus facile ca:

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
#include<stdio.h>
#include<stdlib.h>
#define NB 5
#define RIEN 0
int que=0;
int va=4;
int tailleTab=1;
int cases=0;
int vals=0;
int* tab=NULL, *tete;
void inittab(int **tab)
{
  int i=0;
  *tab=(int*)malloc(sizeof(int)*NB);
  tete=*tab;
  for(;i<NB;i++)
    {
      *((*tab)+i)=RIEN;
    }
}
void afficher(int *tab)
{
  int i;
  for(i=0;i<tailleTab*NB;i++)
    {
      printf("%d ",tab[i]);
    }
  printf("\n");
}
void enfile(int va,int *tab)
{
  int j;
  if(cases<NB*tailleTab)
    {
      *(tab+cases)=va;
      tete++;
      cases++;
 
    }
  else
    {
      tailleTab++;
      //printf("tableau plein %p\n", tab);
      tab=realloc(tab,tailleTab*NB*sizeof(int));
      tab[cases]=va;
      tete++;
      cases++;
 
      for(j=tete-tab+1;j<tailleTab*NB;j++)
	tab [j]=RIEN;
    }
}
void defile(int *tab)
{
*(tab+que)=RIEN;
que++;
}
main()
{
 
inittab(&tab);
afficher(tab);
enfile(2,tab);
afficher(tab);
enfile(3,tab);
afficher(tab);
enfile(4,tab);
afficher(tab);
enfile(5,tab);
afficher(tab);
enfile(6,tab);
afficher(tab);
enfile(7,tab);
afficher(tab);
defile(tab);
afficher(tab);
//defile(tab);
afficher(tab);
}

[Sve@r]

je sais pas pourqoi a chaque fois que je pose une question ici,je retrouve des reponse comliqué,

Mouais. Tu as raison, ça doit venir de nous...

j ai trouvé le probleme,regardé c est pas plus facile ca:

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
#include<stdio.h>
#include<stdlib.h>
#define NB 5
#define RIEN 0
int que=0;
int va=4;
int tailleTab=1;
int cases=0;
int vals=0;
int* tab=NULL, *tete;
void inittab(int **tab)
{
  int i=0;
  *tab=(int*)malloc(sizeof(int)*NB);
  tete=*tab;
  for(;i<NB;i++)
    {
      *((*tab)+i)=RIEN;
    }
}
void afficher(int *tab)
{
  int i;
  for(i=0;i<tailleTab*NB;i++)
    {
      printf("%d ",tab[i]);
    }
  printf("\n");
}
void enfile(int va,int *tab)
{
  int j;
  if(cases<NB*tailleTab)
    {
      *(tab+cases)=va;
      tete++;
      cases++;
 
    }
  else
    {
      tailleTab++;
      //printf("tableau plein %p\n", tab);
      tab=realloc(tab,tailleTab*NB*sizeof(int));
      tab[cases]=va;
      tete++;
      cases++;
 
      for(j=tete-tab+1;j<tailleTab*NB;j++)
	tab [j]=RIEN;
    }
}
void defile(int *tab)
{
*(tab+que)=RIEN;
que++;
}
main()
{
 
inittab(&tab);
afficher(tab);
enfile(2,tab);
afficher(tab);
enfile(3,tab);
afficher(tab);
enfile(4,tab);
afficher(tab);
enfile(5,tab);
afficher(tab);
enfile(6,tab);
afficher(tab);
enfile(7,tab);
afficher(tab);
defile(tab);
afficher(tab);
//defile(tab);
afficher(tab);
}

Que veux-tu qu'on te dise ? On te donne des solutions élégantes, évolutives, modulaires, adaptables... et sans même faire le moindre effort pour les comprendre tu viens nous poser ta bouse. Donc oui c'est 100 fois plus facile ça. Et aussi 100 fois plus pourri. A quoi sert ta variable globale "va" qui vaut 4 ? A quoi sert de répéter tete++ et cases++ dans la fonction "enfile()" ? A quoi sert d'initialiser le contenu du tableau avec "RIEN" étant donné qu'une nouvelle affectation remplacera la valeur d'initialisation ? C'est quand que tu vérifies que malloc/realloc s'est bien passé ? A quoi sert d'appeler la fonction "defile()" si ce n'est pas pour récupérer la dernière valeur empilée ? A quoi sert ta pile en fait ???

Un bon programme ce n'est pas QUE un programme qui fonctionne quand tout va bien surtout que celui-là il marchotte plus qu'il ne fonctionne quoi (as-tu remarqué que ton realloc sera totalement perdu vu que tu stockes son résultat dans une variable locale à la fonction ??? )