Vider liste chainée, problème

Slt j’ai ecrit une fct pour effacer une liste chainée de la memoire mais ça coince, en effet il y a une erreur obscure DAMAGE :after normal block(#42) .
J’ai cherché avec google mais j’ai rien trouvé concernant cette erreur.
Voila le code et merci pour votre aide.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 typedef struct noeud { int val; struct noeud* svt; }noeud; void vider_liste(noeud **n) { noeud *temp=*n; while(n!=NULL) { temp=*n; (*n)=(*n)->svt; free(temp); } }

Code:

1 2 while(*n!=NULL)

Citation:
Envoyé par hunter99
Slt j’ai ecrit une fct pour effacer une liste chainée de la memoire mais ça coince, en effet il y a une erreur obscure DAMAGE :after normal block(#42) .
J’ai cherché avec google mais j’ai rien trouvé concernant cette erreur.
Voila le code et merci pour votre aide.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 typedef struct noeud { int val; struct noeud* svt; }noeud; void vider_liste(noeud **n) { noeud *temp=*n; while(n!=NULL) { temp=*n; (*n)=(*n)->svt; free(temp); } }
Le problème est dans la condition:
Code:

1 2 3 4 while (*n != NULL) { /* ... */ }
Ta fonction devient donc:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 void vider_liste(noeud **n) { if (n != NULL && *n != NULL) { noeud *temp=*n; while(*n != NULL) { temp=*n; (*n)=(*n)->svt; free(temp); } } }
Thierry

ça ne marche pas ! j'ai le meme probleme,est ce que ça fonctionne chez vous ?

le problème c'est est-ce que n==NULL dans le while ?
Est-ce qu'à un moment il est affecté à NULL dans le code ?
8O

Citation:

Envoyé par hunter99

ça ne marche pas ! j'ai le meme probleme,est ce que ça fonctionne chez vous ?

Dans ce cas il faut mettre la casquette avec la siréne sur la tête et passer en pas à pas en mode debugage pour voir ce qu'il se passe. Mets un point d'arrêt à l'entrée de ta fonction et profite-en pour te faire un sandwich (la nuit s'annonce longue...) ;)

Comme cela ne semble toujours pas corriger ton problème de message d'erreur à l'exécution, est-ce que cela ne vient pas du fait que ta fonction vide_liste s'écrive :
Code:

1 2 3 void vider_liste(noeud **n) { ... }
Or comme dans le code de cette fonction, la valeur '*n' est modifiée, la variable passée en argument de la fonction est elle aussi modifiée (ce type d'erreur s'appelle un "effet de bord").

Autrement dit, il n'est plus possible d'utiliser cette variable avec n'importe quelle fonction de traitement d'une liste. Ainsi :
Code:

1 2 3 4 5 6 7 8 9 10 11 int main() { noeud *liste; ... // Je crée ma liste dont la tête est stockée dans liste ... afficher_liste(&liste); // là aucun pb. vider_liste(&racine); // aprés l'appel, la variable liste pointe sur n'importe quoi (plus précisement sur NULL) afficher_liste(&liste) // là il y a une erreur à l'exécution }

Pour désallouer la liste correctement, il faut qu'elle soit allouée correctement, as-tu toujours bien initialisé correctement les (*n)->svt et en particulier le dernier car s'il n'est pas mis à NULL, bonjours les dégats ...
Au point de vue algo, on fait plutôt comme ça d'habitude
Code:

1 2 3 4 5 6 7 8 9 10 11 12 void vider_liste(noeud **n) { if (n != NULL ) { while(*n != NULL) { noeud *temp=(*n)->svt; free(*n); *n = temp; } } }

mchk0123 :

Normalement dans affiche_liste il devrait traiter le cas où le pointeur est NULL (liste vide), d'ailleurs c'est une méthode pour savoir que la liste est effectivement vide.

Bah j'ai pris affiche_liste comme exemple, ça aurais put être n'importe quelle autre fonction.
Et puis même avec affiche_liste, quand on n'est pas trés à l'aise avec le C dés fois on ne penses pas à tous les cas possibles.

re , j'ai lancé debuggué la fonction et elle plante exactement dans le free() dans tous les codes que j'ai essayé , le "DAMAGE: after normal (#50)" affiche l'adresse de la variable temp .
est ce que vous avez une ptite idée de la cause du bug :( ?

Citation:

Envoyé par hunter99

est ce que vous avez une ptite idée de la cause du bug :( ?

Montre le code qui créée la liste.

Pourquoi passer l'adresse du pointeur, vu qu'il n'est jamais modifié ?

Maintenant, j'aimerais avoir le code qui ajoute un noeud dans la liste...

Ceci fonctionne : (EDIT)

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
 
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
 
typedef struct noeud
{
   int val;
   struct noeud *svt;
}
noeud;
 
void voir_liste (noeud * n)
{
   while (n != NULL)
   {
      printf ("%d -> ", n->val);
      n = n->svt;
   }
   printf ("NIL\n");
}
 
noeud *ajouter_liste (noeud * n, int val)
{
   noeud *new = malloc (sizeof *new);
   if (new != NULL)
   {
      new->val = val;
      new->svt = NULL;
      if (n == NULL)
      {
         n = new;
      }
      else
      {
         noeud *p = n;
         while (p->svt != NULL)
         {
            p = p->svt;
         }
         p->svt = new;
      }
   }
   return n;
}
 
/* EDIT : forçage de la tête (de noeud, mouarf!) à NULL */
void vider_liste (noeud **pn)
{
   noeud *n = *pn;
   while (n != NULL)
   {
      noeud *temp = n;
      n = n->svt;
      free (temp);
   }
   *pn = NULL;
}
 
int main (void)
{
   noeud *n = NULL;
 
   n = ajouter_liste (n, 1);
   n = ajouter_liste (n, 2);
   n = ajouter_liste (n, 3);
 
   voir_liste (n);
 
   vider_liste (&n);
 
   assert (n == NULL);
 
   return 0;
}

Citation:

Pourquoi passer l'adresse du pointeur, vu qu'il n'est jamais modifié ?

euh j'ai pas bien saisie ta fonction vider normalement lrsq on va modifier la liste on doit lui passer un noeud** ?

Citation:

Envoyé par hunter99

euh j'ai pas bien saisie ta fonction vider normalement lrsq on va modifier la liste on doit lui passer un noeud** ?

Rien vu de tel dans ton code, alors j'ai zappé.

Citation:

Rien vu de tel dans ton code, alors j'ai zappé.

hein ?

Citation:

Envoyé par hunter99

hein ?

Je n'ai pas vu que tu modifiais n, j'ai donc supprimé une indirection (une * quoi). J'aime quand c'est simple. Le code est généralement moins buggé quand il est simple...

Et bien si, justement sa fonction modifie la variable n passé en paramètre :

Code:

(*n)=(*n)->svt;

Supposons que tu appelles la fonction comme çà :
Code:

1 2 3 noeud *liste; ... vider_liste(&liste);
Et bien dans le cas de la fonction écrite par Emmanuel, aprés l'appel à vider_liste(), liste pointe sur une zone mémoire qui n'est plus allouée.
Alors que la fonction de hunter99, liste pointe sur NULL. Ce qui est plus propre.

Citation:

Envoyé par mchk0123

Et bien si, justement sa fonction modifie la variable n passé en paramètre :

Code:

(*n)=(*n)->svt;

OK. Vu. Je corrige.

Salut,
Citation:
Envoyé par Emmanuel Delahaye
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 #include <stdio.h> #include <stdlib.h> #include <assert.h> (snip) noeud *ajouter_liste (noeud * n, int val) { noeud *new = malloc (sizeof *new); if (new != NULL) { new->val = val; new->svt = NULL; if (n == NULL) { n = new; } else { noeud *p = n; while (p->svt != NULL) { p = p->svt; } p->svt = new; } } return n; } (snip)
Personnellement, je modifierais meme un tout petit peu le code de cette fonction bien précise en de manière à pouvoir ajouter un élément en n'importe quelle position (valide) de la liste...

La seule différence, c'est qu'il s'agira de trouver l'élément apres lequel le nouveau doit etre ajouté avant de d'appeler la fonciton ;)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 noeud *ajouter_liste (noeud * n, int val) { noeud *new = malloc (sizeof *new); if (new != NULL) { new->val = val; if (n == NULL) { new->svt=NULL; n = new; } else { new->svt=n->svt; n->svt=new; } } return n; }
A mon gout, étant donné qu'on parle de liste et non de file, il faut prévoir la possiblité d'un tri (ce qui fait toute la différence entre une file et une liste ;)) et la modification proposée en tient compte ;)

@Emmanuel==>Evidemment, j'ergotte un peu sur les termes... mais tu y es toi meme généralement fort attentif ;)

euh est ce que la fonction de Emmanuel Delahaye supprime reelement la liste ?

Citation:

Envoyé par hunter99

euh est ce que la fonction de Emmanuel Delahaye supprime reelement la liste ?

Sa fonction vide_liste, oui, absolument...

La fonction sur laquelle j'ai réagit, c'est celle d'ajout d'éléments ;)

la fonction de MR Emmanuel garde le premier noeud en memoire.Vu qu'il a fait un passage par valeur sa fonction vider_liste va vider une copie du premier noeud et tous les autres noeuds ensuite c bien ça ?

Citation:

Envoyé par hunter99

la fonction de MR Emmanuel garde le premier noeud en memoire.Vu qu'il a fait un passage par valeur sa fonction vider_liste va vider une copie du premier noeud et tous les autres noeuds ensuite c bien ça ?

On parle bien de ça ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
/* EDIT : forçage de la tête (de noeud, mouarf!) à NULL */
void vider_liste (noeud **pn)
{
   noeud *n = *pn;
   while (n != NULL)
   {
      noeud *temp = n;
      n = n->svt;
      free (temp);
   }
   *pn = NULL;
}

Je ne vois pas de problèmes dans ce code. Je l'ai passé au détecteurs de mensonges :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
Usage xxx[ /T][ /E][ /O][ <options application>]
FRMWRK.DBG_SYSALLOC=1
SYSALLOC Overload (85 rec)
SYSALLOC Successful initialization: 85 records available
SYSALLOC 'M 003D3BA8      8 4294967295   24:main.c'
SYSALLOC 'M 003D3B98      8 4294967295   24:main.c'
SYSALLOC 'M 003D3B88      8 4294967295   24:main.c'
1 -> 2 -> 3 -> NIL
SYSALLOC 'F 003D3BA8      0 4294967295   54:main.c'
SYSALLOC 003D3BA8 matched
SYSALLOC 'F 003D3B98      0 4294967295   54:main.c'
SYSALLOC 003D3B98 matched
SYSALLOC 'F 003D3B88      0 4294967295   54:main.c'
SYSALLOC 003D3B88 matched
SYSALLOC min=4294967295 max=4294967295 delta=0
SYSALLOC All-matched
SYSALLOC Released Memory
FRMWRK.Termine
 
Press ENTER to continue.

Citation:

la fonction de MR Emmanuel garde le premier noeud en memoire.Vu qu'il a fait un passage par valeur sa fonction vider_liste va vider une copie du premier noeud et tous les autres noeuds ensuite c bien ça ?

Citation:

On parle bien de ça ?

non je parlais de ça :
Code:

1 2 3 4 5 6 7 8 9 10 void vider_liste (noeud *n) { noeud *temp = n; while (n != NULL) { temp = n; n = n->svt; free (temp); } }

Citation:
Envoyé par hunter99
non je parlais de ça :
Code:

1 2 3 4 5 6 7 8 9 10 void vider_liste (noeud *n) { noeud *temp = n; while (n != NULL) { temp = n; n = n->svt; free (temp); } }
Laisse tomber ce code là. Je l'ai effacé. C'est le 2ème qui fonctionne.

slt,:coucou: j'ai essayé ta fonction et elle marche:) , apparement le probleme vient de ma fonction d'ajout mais j'ai pas compris sa cause :( .En effet lrsq j'ajoute un element avec ma fonction ajout_liste_qui_plante ça marche niquel mais si je la vide ça plante , alors que la meme maneuvre fonctionne avec ajouter_liste de MR Emmanuel :aie: ! j'ai essayé le debug mais le resultat des 2 fonctions d'ajout est identique.Svp est ce que qlqn peut m'expliquer la cause du probleme ?

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
#include <stdio.h> f
merci
#include <stdlib.h>
 
 
 
 
typedef struct noeud
{ 
	int val;
	struct noeud* svt;
}noeud;
void ajouter_liste_qui_plante (noeud ** n, int val) // ma fonction qui cause le 
                                                                   // le plantage
{
	noeud *temp=*n;
 
	if (temp==NULL)
	{
		*n=malloc(sizeof *n);
		(*n)->svt=NULL;
		(*n)->val=val;
	}
	else
	{
		while (temp->svt!=NULL)
		{
			temp=temp->svt;
		}
		temp->svt=malloc(sizeof *temp->svt);
		temp=temp->svt;
		temp->svt=NULL;
		temp->val=val;
	}
}
 
 
void ajouter_liste (noeud ** n, int val)// fct d'Emmanuel
{
  noeud *new = malloc (sizeof *new);
   if (new != NULL)
   {
      new->val = val;
      new->svt = NULL;
      if (*n == NULL)
      {
         *n = new;
      }
      else
      {
         noeud *p = *n;
         while (p->svt != NULL)
         {
            p = p->svt;
         }
         p->svt = new;
      }
   }
 
}
 
void vider_liste (noeud **pn)// fct d'Emmanuel
{
   noeud *n = *pn;
   while (n != NULL)
   {
      noeud *temp = n;
      n = n->svt;
      free (temp);
	}
   *pn = NULL;
}
 
int main()
{
noeud *n=NULL,*m=NULL;
 
ajouter_liste_qui_plante(&n,1);
ajouter_liste_qui_plante(&n,2);
ajouter_liste(&m,1);
ajouter_liste(&m,2);
 
vider_liste(&n);
vider_liste(&m);
 
 
return 0;
}

Citation:

Envoyé par hunter99

slt,:coucou: j'ai essayé ta fonction et elle marche:) , apparement le probleme vient de ma fonction d'ajout mais j'ai pas compris sa cause :( .En effet lrsq j'ajoute un element avec ma fonction ajout_liste_qui_plante ça marche niquel mais si je la vide ça plante , alors que la meme maneuvre fonctionne avec ajouter_liste de MR Emmanuel :aie: ! j'ai essayé le debug mais le resultat des 2 fonctions d'ajout est identique.Svp est ce que qlqn peut m'expliquer la cause du probleme ?

Pour moi les deux fonctions se comportent normalement.

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
 
Usage xxx[ /T][ /E][ /O][ <options application>]
FRMWRK.DBG_SYSALLOC=1
SYSALLOC Overload (85 rec)
SYSALLOC Successful initialization: 85 records available
SYSALLOC 'M 003D3B70      4 4294967295   17:main.c'
SYSALLOC 'M 003D3B60      8 4294967295   28:main.c'
SYSALLOC 'M 003D3B50      8 4294967295   28:main.c'
SYSALLOC 'M 003D2430      8 4294967295   28:main.c'
1 -> 2 -> 3 -> 4 -> NIL
SYSALLOC 'F 003D3B70      0 4294967295   69:main.c'
SYSALLOC 003D3B70 matched
SYSALLOC 'F 003D3B60      0 4294967295   69:main.c'
SYSALLOC 003D3B60 matched
SYSALLOC 'F 003D3B50      0 4294967295   69:main.c'
SYSALLOC 003D3B50 matched
SYSALLOC 'F 003D2430      0 4294967295   69:main.c'
SYSALLOC 003D2430 matched
SYSALLOC min=4294967295 max=4294967295 delta=0
SYSALLOC All-matched
SYSALLOC Released Memory
FRMWRK.Termine
 
Press ENTER to continue.

et

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
 
Usage xxx[ /T][ /E][ /O][ <options application>]
FRMWRK.DBG_SYSALLOC=1
SYSALLOC Overload (85 rec)
SYSALLOC Successful initialization: 85 records available
SYSALLOC 'M 003D3B70      8 4294967295   38:main.c'
SYSALLOC 'M 003D3B60      8 4294967295   38:main.c'
SYSALLOC 'M 003D3B50      8 4294967295   38:main.c'
SYSALLOC 'M 003D2430      8 4294967295   38:main.c'
1 -> 2 -> 3 -> 4 -> NIL
SYSALLOC 'F 003D3B70      0 4294967295   69:main.c'
SYSALLOC 003D3B70 matched
SYSALLOC 'F 003D3B60      0 4294967295   69:main.c'
SYSALLOC 003D3B60 matched
SYSALLOC 'F 003D3B50      0 4294967295   69:main.c'
SYSALLOC 003D3B50 matched
SYSALLOC 'F 003D2430      0 4294967295   69:main.c'
SYSALLOC 003D2430 matched
SYSALLOC min=4294967295 max=4294967295 delta=0
SYSALLOC All-matched
SYSALLOC Released Memory
FRMWRK.Termine
 
Press ENTER to continue.

Avec ce 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
 
#include <stdio.h>
#include <stdlib.h>
typedef struct noeud
{
   int val;
   struct noeud *svt;
}
noeud;
 
#if 0
// ma fonction qui cause le
// le plantage
void ajouter_liste (noeud ** n, int val)
{
   if (*n == NULL)
   {
      *n = malloc (sizeof *n);
      (*n)->svt = NULL;
      (*n)->val = val;
   }
   else
   {
      noeud *temp = *n;
      while (temp->svt != NULL)
      {
         temp = temp->svt;
      }
      temp->svt = malloc (sizeof *temp->svt);
      temp = temp->svt;
      temp->svt = NULL;
      temp->val = val;
   }
}
#else
// fct d'Emmanuel
void ajouter_liste (noeud ** n, int val)
{
   noeud *new = malloc (sizeof *new);
   if (new != NULL)
   {
      new->val = val;
      new->svt = NULL;
 
      if (*n == NULL)
      {
         *n = new;
      }
      else
      {
         noeud *p = *n;
         while (p->svt != NULL)
         {
            p = p->svt;
         }
         p->svt = new;
      }
   }
}
#endif
 
// fct d'Emmanuel
void vider_liste (noeud ** pn)
{
   noeud *n = *pn;
   while (n != NULL)
   {
      noeud *temp = n;
      n = n->svt;
      free (temp);
   }
   *pn = NULL;
}
 
void afficher_liste (noeud * n)
{
   noeud *p = n;
 
   while (p != NULL)
   {
      printf ("%d -> ", p->val);
      p = p->svt;
   }
   printf ("NIL\n");
}
 
int main (void)
{
   noeud *n = NULL, *m = NULL;
   ajouter_liste (&n, 1);
   ajouter_liste (&n, 2);
   ajouter_liste (&n, 3);
   ajouter_liste (&n, 4);
   afficher_liste (n);
   vider_liste (&n);
   vider_liste (&m);
   return 0;
}

tu a quoi comme compilo ? Est ce que tu peut l'essayer sur le visual 6 si c'est possible ?
merci :king:

Citation:

Envoyé par hunter99

tu a quoi comme compilo ?

MinGW.

Citation:

Est ce que tu peut l'essayer sur le visual 6 si c'est possible ?

Je n'ai plus ça en magasin depuis longtemps. Le moins de Microsoft possible chez moi...

tu pense que c'est normal que ça plante sous visual et que ça marche sous c::b:aie: ?

Citation:

Envoyé par hunter99

tu pense que c'est normal que ça plante sous visual et que ça marche sous c::b:aie: ?

Non, mais comme je ne sais pas ce que tu appelles 'plante', je ne peux en dire plus.

Dans ta fonction ajouter_liste_qui_plante, tu as (au moins) une erreur :

Code:

1
2
3
4
5
6
7
8
9
10
11
void ajouter_liste_qui_plante (noeud ** n, int val) // ma fonction qui cause le 
                                                                   // le plantage
{
...
	else
	{
...
                 // Erreur dans la ligne mis en commentaire
                 //   car il ne faut pas de * (alors qu'avec n, il faut bien une *)
	         //temp->svt=malloc(sizeof *temp->svt);
                 temp->svt=malloc(sizeof temp->svt);

Peut être que ton pb. viens de là.

mchk0123>j'ai reparé l'erreur mais ça ne change rien
Emmanuel>Damage after normal block (#42) at (une adresse)

Citation:

Envoyé par hunter99

mchk0123>j'ai reparé l'erreur mais ça ne change rien
Emmanuel>Damage after normal block (#42) at (une adresse)

42 ! Tout peut arriver ! :)

Je ne vois pas.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void ajouter_liste_qui_plante(noeud ** n, int val)
 {
 noeud *temp=*n;
	
 if (temp==NULL)
  {
  *n=malloc(sizeof (noeud));
  (*n)->svt=NULL;
  (*n)->val=val;
  }
 else
  {
  while (temp->svt!=NULL)
   {
   temp=temp->svt;
   }
  temp->svt=malloc(sizeof *temp->svt);
  temp=temp->svt;
  temp->svt=NULL;
  temp->val=val;
  }
 }

Citation:

Envoyé par mchk0123

Dans ta fonction ajouter_liste_qui_plante, tu as (au moins) une erreur :

Code:

1
2
3
4
5
6
7
8
9
10
11
void ajouter_liste_qui_plante (noeud ** n, int val) // ma fonction qui cause le 
                                                                   // le plantage
{
...
	else
	{
...
                 // Erreur dans la ligne mis en commentaire
                 //   car il ne faut pas de * (alors qu'avec n, il faut bien une *)
	         //temp->svt=malloc(sizeof *temp->svt);
                 temp->svt=malloc(sizeof temp->svt);

Faux.

Citation:

temp->svt=malloc(sizeof *temp->svt);

est correct.

http://emmanuel-delahaye.developpez....tes.htm#malloc

Citation:
Envoyé par stephl
Code:

1 2 3 4 5 6 7 void ajouter_liste_qui_plante(noeud ** n, int val) { noeud *temp=*n; if (temp==NULL) { *n=malloc(sizeof (noeud));
Oui bien vu. On peut aussi mettre sizeof **n.

-> PO : C'est ça ton bug.
Citation:
Code:

1 2 3 4 5 void ajouter_liste (noeud ** n, int val) { if (*n == NULL) { *n = malloc (sizeof *n);
n étant un **, la taille de *n est cette d'un pointeur. Pour avoir la taille de l'objet pointé, c'est sizeof *(*n) ou sizeof **n.

C'est un comportement indéfini, tout peut arriver, y compris un comportement d'apparence normal.

J'évite les pointeurs doubles au maximum. Trop de risques d'erreurs. Tu remarqueras que dans ma correction, je suis instinctivement descendu d'un niveau. Je ne manipule le ** qu'en fin de course.

Attention, j'ai corrigé mon post précédent. J'avais oublié les parenthèses autour du nom de type pour sizeof.

Merci bcp c’est bien ça .
Moralité de l’histoire : faire gaffe au pointeur double :mrgreen:

Citation:

Envoyé par Emmanuel Delahaye

Faux.
est correct.

Mes excuses les plus ....

J'ai rajouté un bug là où il n'y en avait pas,
mais à la même ligne que l'autre alternative où il en avait un !
Je doit avoir les neurones qui se touchent avec l'âge ! :mouarf: