Liste simplement chainée

Version imprimable

Voir 40 message(s) de cette discussion en une page

26/11/2005, 19h28
sorry60
Citation:
Envoyé par Emmanuel Delahaye

on définit une structure supplémentaire est est la liste.

Code:

1 2 3 4 5 6 struct list { struct node *p_head; struct node *p_tail; };

Ce que tu appelais 'liste' est en fait un 'node'

Code:

1 2 3 4 5 6 struct node { struct node *p_next; /* data ... */ };

Les fonctions gèrent alors les deux pointeurs (début et fin). Le pointeur de fin permet d'accélerer le traitement (plus besoin de faire une boucle pour ajouter en fin)...

Maintenant, tous devient simple et clair :

Code:

1 2 3 4 5 6 7 /* evidemment, il ne vaut pas oublier ca ! */ struct list Liste = {0}; ajouter(&Liste, 123); ajouter(&Liste, 456); ajouter(&Liste, 789);
Alors j'ai quelques questions avant d'attaquer le code :
:arrow: la structure list, ne sert qu'à repérer le debut et la fin de ma liste ?
:arrow: mon ancienne structure devient comme cela :
Code:

1 2 3 4 struct node { struct node *suivant; int val; }
:arrow: que fait cette ligne :

Code:

struct list Liste = {0};

J'ai un peu de mal à debuter, j'espere que les réponses me le permettront. Merci pour ton aide :D
26/11/2005, 19h38
Emmanuel Delahaye
Citation:

Envoyé par sorry60

:arrow: la structure list, ne sert qu'à repérer le debut et la fin de ma liste ?

Oui, et c'est essentiel. Tu perds ça, t'es mort!
Citation:
:arrow: mon ancienne structure devient comme cela :

Code:

1 2 3 4 struct node { struct node *suivant; int val; }
Oui.

Citation:

:arrow: que fait cette ligne :

Code:

struct list Liste = {0};

Elle définit une structure et met tous ses élements à 0. Comme se sont des pointeurs, ça va faire NULL.

Je sais que tu vas y arriver.

Voila mon nouveau code :

Le header :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
#include <stdlib.h>
 
typedef struct node {
	struct node *pSuivant;
	int val;
}node;
 
typedef struct list {
	struct node *pTete;
	struct node *pQueue;
}list;
 
/* Fonction qui ajoute un élément en fin de liste */
node* ajouter(node *p,int valeur);

Le .c avec la fonction d'ajout :

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
 
#ifdef __cplusplus
#error Be sure you are using a C compiler...
#endif
 
#include "liste.h"
 
/* Fonction qui ajoute un élément en fin de liste */
node* ajouter(node *p,int valeur)
{
	node *nouv = malloc(sizeof(*nouv));
 
	if(nouv)
	{
		nouv->val = valeur;
		nouv->pSuivant = NULL;
		/* On teste si la liste est vide */
		if( !p )
		{
			/* On ajoute directement le nouvel element */
			p = nouv;
		}
		else
		{
			/* On parcourt la liste jusqu'au dernier element */
			while(p->pSuivant)
			{
				p = p->pSuivant;
			}
			/* On insere le nouvel element */
			p->pSuivant = nouv;
		}
	}
	else
	{
		perror("malloc()");
		exit(1);
	}
	return p;
}

Et le main :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
#ifdef __cplusplus
#error Be sure you are using a C compiler...
#endif
 
#include "liste.h"
 
int main()
{
	/* notre pointeur sur une liste bientot chainée ! */
	list* pMaListe = {0};
 
	/* On ajoute quelques elements */
	pMaListe = ajouter(pMaListe,1);
	system("Pause");
	return 0;
}

La compil' passe impect, je pense que le code est correct. Par contre je ne vois pas comment récuperer la tete et la queue :?
En faisant

Code:

list *pDebMaListe = pMaListe->pTete;

:?:

Edit : ce code ne compile pas, car à ajouter je passe un list* au lieu d'un *node, mais comme je ne comprend pas, je prefere le mettre, histoire de ne pas cacher mon ignorance :?

Citation:

Envoyé par sorry60

Voila mon nouveau code :
<...>
La compil' passe impect, je pense que le code est correct.

Pas du tout. La conception n'est pas bonne.

L'interface de la fonction est maintenant
Code:

1 2 3 /* Fonction qui ajoute un élément en fin de liste */ void ajouter(list *p, int valeur);
Tout le reste doit être modifié en conséquence.

Et les pointeurs pTete et pQueue ne vont pas bouger tout seuls...

J'ai ceci qui fonctionne :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 #include "liste.h" int main() { /* notre pointeur sur une liste bientot chainée ! */ struct list MaListe = {0}; /* On ajoute quelques elements */ ajouter (&MaListe, 1); ajouter (&MaListe, 2); ajouter (&MaListe, 3); afficher (&MaListe); liberer (&MaListe); return 0; }
Je te laisse compléter les fichiers liste.h et liste.c.

Ca donne ça :
Code:

1 2 3 4 1 2 3

J'avoue que j'ai beaucoup de mal à saisir le truc :?
Voici le main :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
int main()
{
	/* notre pointeur sur une liste bientot chainée ! */
	list maListe = {0};
 
	/* On ajoute quelques elements */
	ajouter(&maListe,1);
	ajouter(&maListe,2);
	ajouter(&maListe,3);
 
	/* On affiche */
	afficher(&maListe);
 
	system("Pause");
	return 0;
}

Le .h :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
#include <stdio.h>
#include <stdlib.h>
 
typedef struct node {
	struct node *pSuivant;
	int val;
}node;
 
typedef struct list {
	struct node *pTete;
	struct node *pQueue;
}list;
 
/* Fonction qui ajoute un élément en fin de liste */
void ajouter(list *p,int valeur);
/* Fonction qui affiche la liste chainée */
void afficher(list *p);

Et le code des fonctions d'ajout et d'affichage :

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
 
/* Fonction qui ajoute un élément en fin de liste */
void ajouter(list *p,int valeur)
{
	list *nouv = malloc(sizeof(*nouv));
 
	if(nouv)
	{
		nouv->pTete->val = valeur;
		nouv->pTete->pSuivant = NULL;
		nouv->pQueue = NULL;
		/* On teste si la liste est vide */
		if( !p )
		{
			/* On ajoute directement le nouvel element */
			p = nouv;
		}
		else
		{
			/* On parcourt la liste jusqu'au dernier element */
			while(p->pTete->pSuivant)
			{
    			p->pTete = p->pTete->pSuivant;
			}
			/* On insere le nouvel element */
			p = nouv;
		}
	}
	else
	{
		perror("malloc()");
		exit(1);
	}
}
 
/* Fonction qui affiche la liste chainée */
void afficher(list *p)
{
	while(p->pTete)
	{
		printf("%d\n",p->pTete->val);
		p->pTete = p->pTete->pSuivant;
	}
}

A la compil' j'ai deux warnings :

Citation:

10 C:\Documents and Settings\Thomas\Mes documents\Langage C\Exercices\Listes\SimplementChainée\main.c [Warning] missing initializer
10 C:\Documents and Settings\Thomas\Mes documents\Langage C\Exercices\Listes\SimplementChainée\main.c [Warning] (near initialization for `maListe.pQueue')

Pour la ligne :

Code:

list maListe = {0};

Et à l'execution, une erreur d'ecriture en zone mémoire protégée (je m'en doutais..).

Toujours le même problème sur les pointeurs : si tu veux que le pointeur soit modifié au retour de la fonciton, donne l'adresse de ce pointeur.
donc :

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
/* Fonction qui ajoute un élément en fin de liste */
void ajouter(list **p,int valeur)
{
   list *nouv = malloc(sizeof(*nouv));
 
   if(nouv)
   {
      nouv->pTete->val = valeur;
      nouv->pTete->pSuivant = NULL;
      nouv->pQueue = NULL;
      /* On teste si la liste est vide */
      if( !(*p) )
      {
         /* On ajoute directement le nouvel element */
         *p = nouv;
      }
      else
      {
         /* On parcourt la liste jusqu'au dernier element */
         list *tmp = *p;
         while(tmp->pTete->pSuivant)
         {
             tmp->pTete = tmp->pTete->pSuivant;
         }
         /* On insere le nouvel element */
         tmp = nouv;
      }
   }
   else
   {
      perror("malloc()");
      exit(1);
   }
}

Il aurait d'ailleurs été meilleur que ta fonction retourne un pointeur list *.

27/11/2005, 14h06
sorry60
J'essaye d'eviter les ** pour le moment vu que je debute avec les listes :?
Donc je m'eforce de suivre ce que me dis Emmanuel Delaye :
Citation:
Envoyé par Emmanuel Delahaye

L'interface de la fonction est maintenant
Code:

Code:

1 2 3 /* Fonction qui ajoute un élément en fin de liste */ void ajouter(list *p, int valeur);
Mais je me perd un peu dans toutes ces structures...et je ne vois pas comment faire bouger la tete de la liste :(

Citation:

Envoyé par sorry60

J'avoue que j'ai beaucoup de mal à saisir le truc :?

Y'a pas de 'truc'. C'est de la programmation la plus simple et directe qu'il soit...

Citation:

Voici le main :
<...>
Le .h :
<...>

Jusque là, ça va, à part ce commentaire :

Code:

/* notre pointeur sur une liste bientot chainée ! */

Je ne vois pas de pointeur, mais une structure.
Citation:
Et le code des fonctions d'ajout et d'affichage :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 /* Fonction qui ajoute un élément en fin de liste */ void ajouter(list *p,int valeur) { list *nouv = malloc(sizeof(*nouv)); if(nouv) { nouv->pTete->val = valeur; nouv->pTete->pSuivant = NULL; nouv->pQueue = NULL; /* On teste si la liste est vide */ if( !p )
NON. La liste est vide si p->pTete vaut NULL.
Citation:
Code:

1 2 3 4 { /* On ajoute directement le nouvel element */ p = nouv;
Et il faudrait peut être mettre à jour p->pTete et p->pQueue, non ? Ca va pas se faire tout seul.

C'est pas compliqué. On a collé les deux pointeurs pTete et pQueue dans une une structure liste. Les fonctions de listes sont là pour gérer ces pointeurs (initialisation, mise à jour, lecture). Je ne vois pas ce qu'il y a de compliqué.
Citation:
Code:

1 2 3 4 5 } else { /* On parcourt la liste jusqu'au dernier element */
NON. Il suffit de lire p->pQueue. Evidemment il faut qu'il soit à jour... C'est justement pour éviter cette boucle qu'on a crée pQueue. C'est si difficile à comprendre ?

Par contre, il faire le lien et mettre a jour le pointeur de fin (pQueue). Tu as fait le schéma comme je te l'ai demandé ?
Citation:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 while(p->pTete->pSuivant) { p->pTete = p->pTete->pSuivant; } /* On insere le nouvel element */ p = nouv; } } else { perror("malloc()"); exit(1); } } /* Fonction qui affiche la liste chainée */ void afficher(list *p) { while(p->pTete)
NON ! Il faut utiliser un pointeur local. Pour lire un objet, on a pas le droit de le modifier.

Code:

void afficher(list const *p)

évite les bétises...

D'ailleurs, j'avais écrit (je ne retrouve plus l'original) un truc du genre :

Citation:

Envoyé par -ed-

Dans une liste chainée, le pointeur de tête est essentiel. Si tu le perd, t'es mort!

Or là, tu le modifies sans vergogne.

27/11/2005, 14h54
Emmanuel Delahaye

Citation:

Envoyé par Trap D

Toujours le même problème sur les pointeurs : si tu veux que le pointeur soit modifié au retour de la fonciton, donne l'adresse de ce pointeur.
donc :
[code]/* Fonction qui ajoute un élément en fin de liste */
void ajouter(list **p,int valeur)

Argh! Tu n'as pas suivit tous les épisodes. Maintenant on a une structure liste qui évite ce genre de sport.

M'enfin, c'est si compliqué que ça d'écrire du code simple ?
27/11/2005, 14h59
Emmanuel Delahaye
Citation:
Envoyé par sorry60

Citation:

Envoyé par Emmanuel Delahaye

L'interface de la fonction est maintenant
Code:

Code:

1 2 3 /* Fonction qui ajoute un élément en fin de liste */ void ajouter(list *p, int valeur);

Mais je me perd un peu dans toutes ces structures...
Gné ? Il n'y a que 2 structures !

list et node.

list a les deux pointeurs tete et queue. node a les chainages (suivant) et les données. Tu l'as enfin fait ce schéma, ou je parle aux murs ?

Citation:

et je ne vois pas
comment faire bouger la tete de la liste

Ca se passe une fois lors de l'ajout du premier élément.

FAIT LE SCHEMA
27/11/2005, 16h59
sorry60

Citation:

Envoyé par Emmanuel Delahaye

Gné ? Il n'y a que 2 structures !

list et node.

list a les deux pointeurs tete et queue. node a les chainages (suivant) et les données. Tu l'as enfin fait ce schéma, ou je parle aux murs ?

Citation:

et je ne vois pas
comment faire bouger la tete de la liste

Ca se passe une fois lors de l'ajout du premier élément.

FAIT LE SCHEMA

J'y vais, là je revisais un peu mon assembleur pour demain.
Merci pour tes explications, je vais faire ce fameux schema :wink:

J'ai fait un schéma, j'espere qu'il est bon..je vais essayer de le redessiner ici :?

Code:

1
2
3
4
5
6
7
8
9
10
11
 
Avant tout ajout :
   pTete -> NULL
   pQueue -> NULL
 
Apres un ajout :
   pTete et pQueue -> nouv1 -> NULL
 
Encore un ajout :
   pTete -> nouv1 -> nouv2 -> NULL
   pQueue -> nouv2

Ce qui me mène au code suivant pour la fonction d'ajout :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
void ajouter(list *p,int valeur)
{
	node nouv;
	nouv.val = valeur;
	nouv.pSuivant = NULL;
	/* Si la liste est vide */
	if( !p->pTete )
	{
		/* Le nouvel element est à la fois tete et queue */
		p->pTete = &nouv;
		p->pQueue = &nouv;
	}
	else
	{
		/* La liste n'est pas vide, le dernier élément est pQueue */
		p->pQueue = &nouv;
		p->pTete->pSuivant = p->pQueue;
	}
}

Vai-je encore récolter les foudres d'Emmanuel ? :wink:

27/11/2005, 17h58
Jack_serious

Fais gaffe !

d'apres ton code, nouv est une variable locale !

Fais un malloc, sinon ton nouvel element va disparaitre dans les profondeurs intersiderales de l'insondable des la sortie de ta fonction...

Pour le reste, il y a du mieux mais c'est encore un peu bancal. M'est avis que tu te complique la vie pour rien.

Le pointeur pTete a besoin d'etre initialise une seule fois (deux en fait, mais je ne compte pas la mise a NULL) : lors de l'ajout du premier element.

Par la suite, il suffit de faire pointer pQueue sur l'element que tu viens d'ajouter.
27/11/2005, 17h59
scol30
un seul petit problème dans ta fonction ajouter. il te faut utiliser un
Code:

1 2 node * nouv; nouv = malloc(sizeof(*nouv));
sinon la variable est détruite à la sortie de ta fonction.
Ensuite si tu ajoutes dans liste non vide alors
Code:

1 2 3 p->pQueue->pSuivant = nouv; p->pQueue=nouv;
Stef

Citation:
Envoyé par sorry60
J'ai fait un schéma, j'espere qu'il est bon..je vais essayer de le redessiner ici :?
Code:

1 2 3 4 5 6 7 8 9 10 11 Avant tout ajout : pTete -> NULL pQueue -> NULL Apres un ajout : pTete et pQueue -> nouv1 -> NULL Encore un ajout : pTete -> nouv1 -> nouv2 -> NULL pQueue -> nouv2
AAAAHHH!
Ca va tout de suite aller mieux, non ?
Citation:
Ce qui me mène au code suivant pour la fonction d'ajout :
Code:

1 2 3 4 void ajouter(list *p,int valeur) { node nouv;
ARG! Ou est passé le malloc () ?
Citation:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 nouv.val = valeur; nouv.pSuivant = NULL; /* Si la liste est vide */ if( !p->pTete ) { /* Le nouvel element est à la fois tete et queue */ p->pTete = &nouv; p->pQueue = &nouv; } else { /* La liste n'est pas vide, le dernier élément est pQueue */ p->pQueue = &nouv; p->pTete->pSuivant = p->pQueue; } }
Vai-je encore récolter les foudres d'Emmanuel ? :wink:
A ton avis ?
http://www.poster.net/davey-allan/da...re-2203404.jpg
Mais pourquoi as-tu retiré le malloc() ? Depuis quand une variable locale est-elle persistante après la fonction ?

Le reste, c'est presque ça, mais tu t'emmelles dans les chainages...

La liste n'est pas vide :
1 - On utilise le pointeur de queue pour mettre à jour le chainage
2 - On met à jour le pointeur de queue.

Pour cette opération on a jamais besoin du pointeur de tête.

Integre tout ça dans ton code, et tu y es.

Citation:

Envoyé par Emmanuel Delahaye

Mais pourquoi as-tu retiré le malloc() ? Depuis quand une variable locale est-elle persistante après la fonction ?

Le reste, c'est presque ça, mais tu t'emmelles dans les chainages...

La liste n'est pas vide :
1 - On utilise le pointeur de queue pour mettre à jour le chainage
2 - On met à jour le pointeur de queue.

Pour cette opération on a jamais besoin du pointeur de tête.

Integre tout ça dans ton code, et tu y es.

Oui en effet je sais pas pourquoi j'ai enlevé le malloc :?
De plus mon rechainage n'etait pas top car en mettant 2 éléments ça marchait bien mais pas pour plus..
J'ai donc refais un schema pour l'ajout de plus d'elements et j'ai corrigé mon erreur.
Voici le code final des fonctions d'ajout et d'affichage :
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 /* Fonction qui ajoute un élément en fin de liste */ void ajouter(list *p,int valeur) { node *nouv = malloc(sizeof(*nouv)); nouv->val = valeur; nouv->pSuivant = NULL; /* Si la liste est vide */ if( !p->pTete ) { /* Le nouvel element est à la fois tete et queue */ p->pTete = nouv; p->pQueue = nouv; } else { /* La liste n'est pas vide, le dernier élément est pQueue */ p->pQueue->pSuivant = nouv; p->pQueue = nouv; } } /* Fonction qui affiche la liste chainée */ void afficher(list const *p) { node *tmp = p->pTete; while ( tmp ) { printf("%d\n",tmp->val); tmp = tmp->pSuivant; } }
J'attend le tampon avant d'attaquer la suppression :wink:

Edit : il y a toujours ces deux warnings persistants :

Citation:

10 C:\Documents and Settings\Thomas\Mes documents\Langage C\Exercices\Listes\SimplementChainée\main.c [Warning] missing initializer
10 C:\Documents and Settings\Thomas\Mes documents\Langage C\Exercices\Listes\SimplementChainée\main.c [Warning] (near initialization for `maListe.pQueue')

Pour la ligne :
Code:

1 2 /* notre liste bientot chainée ! */ list maListe = {0};

Citation:
Envoyé par sorry60
Oui en effet je sais pas pourquoi j'ai enlevé le malloc :?
Voici le code final des fonctions d'ajout et d'affichage :
Code:

1 2 3 4 5 /* Fonction qui ajoute un élément en fin de liste */ void ajouter(list *p,int valeur) { node *nouv = malloc(sizeof(*nouv));
Ouiiinnn ! Et le test si malloc() echoue ? Tu as détruit du code qui était bon. Pourquoi ? Accès de mauvaise humeur ?
Citation:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 nouv->val = valeur; nouv->pSuivant = NULL; /* Si la liste est vide */ if( !p->pTete ) { /* Le nouvel element est à la fois tete et queue */ p->pTete = nouv; p->pQueue = nouv; } else { /* La liste n'est pas vide, le dernier élément est pQueue */ p->pQueue->pSuivant = nouv; p->pQueue = nouv;
OK
Citation:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 } } /* Fonction qui affiche la liste chainée */ void afficher(list const *p) { node *tmp = p->pTete; while ( tmp ) { printf("%d\n",tmp->val); tmp = tmp->pSuivant;
OK
Citation:
Code:

1 2 3 } }
J'attend le tampon avant d'attaquer la suppression :wink:

Edit : il y a toujours ces deux warnings persistants :

Citation:

10 C:\Documents and Settings\Thomas\Mes documents\Langage C\Exercices\Listes\SimplementChainée\main.c [Warning] missing initializer
10 C:\Documents and Settings\Thomas\Mes documents\Langage C\Exercices\Listes\SimplementChainée\main.c [Warning] (near initialization for `maListe.pQueue')

Pour la ligne :
Code:

1 2 /* notre liste bientot chainée ! */ list maListe = {0};
Il y a deux élements. gcc qui est plutôt 'picky' la-dessus, demande que tous les élements soient initialisés (ce qui va au-dela de la norme)
Code:

1 2 /* notre liste bientot chainée ! */ list maListe = {NULL, NULL};
pour etre cohérent.

27/11/2005, 18h37
sorry60

J'ai remis le test du retour de malloc().
J'attaque la fonction retirer.

Merci beaucoup pour ton aide :hola:

Voila ma fonction qui retire un élément precis.
Je l'ai testé, ça a l'air d'etre bon.

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
/* Fonction qui retire un element precis */
void retirer(list *p, int valeur)
{
	/* Si la liste est vide...*/
	if( !p->pTete )
	{
		printf("La liste est vide !\n");
		return;
	}
	/* Si l'element à retirer est le seul de la liste */
	if( (!p->pTete->pSuivant) && (p->pTete->val == valeur))
	{
		free(p->pTete);
		free(p->pQueue);
		p->pTete = NULL;
		p->pQueue = NULL;
	}
	else
	{
		node *tmp = p->pTete;
		node *prec = malloc(sizeof(*prec));
		if(prec)
		{
			/* On se positionne sur le bon element */
			while ( tmp && (tmp->val != valeur) )
			{
				prec = tmp;
				tmp = tmp->pSuivant;
			}
			/* Si l'element a été trouvé */
			if ( tmp != NULL )
			{
				/* on rechaine sans l'element a supprimer */
				prec->pSuivant = tmp->pSuivant;
				/* on supprime l'element */
				free(tmp);
			}
			else
			{
				printf("Element absent !\n");
			}
		}
		else
		{
			perror("malloc()");
			exit(1);
		}
	}
}

Le main :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
int main()
{
	/* notre liste bientot chainée ! */
	list maListe = {0};
 
	/* On ajoute quelques elements */
	ajouter(&maListe,1);
	ajouter(&maListe,2);
	ajouter(&maListe,3);
	ajouter(&maListe,4);
	ajouter(&maListe,5);
	/* On affiche */
	printf("Avant :\n");
	afficher(&maListe);
	/* On le retire */
	retirer(&maListe,3);
	/* On affiche */
	printf("Apres :\n");
	afficher(&maListe);
	system("Pause");
	return 0;
}

Donne :

Citation:

Avant :
1
2
3
4
5
Apres :
1
2
4
5
Appuyez sur une touche pour continuer...

"Lu et approuvé" :) :?: :?:

Citation:

Envoyé par sorry60

Voila ma fonction qui retire un élément precis.
Je l'ai testé, ça a l'air d'etre bon.
<...>
"Lu et approuvé" :) :?: :?:

Non. Il y a un problème de libération.

Avec ce main():
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 int main() { list maListe = {0, 0}; /* On ajoute quelques elements */ ajouter(&maListe,1); ajouter(&maListe,2); ajouter(&maListe,3); /* On affiche */ printf("Avant :\n"); afficher(&maListe); /* On le retire */ printf("On retire 2 :\n"); retirer(&maListe,2); /* On affiche */ afficher(&maListe); printf("On retire 3 :\n"); retirer(&maListe,3); /* On affiche */ afficher(&maListe); printf("On retire 1 :\n"); retirer(&maListe,1); /* On affiche */ afficher(&maListe); return 0; }
On obtient :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 Avant : 1 2 3 On retire 2 : 1 3 On retire 3 : 1 On retire 1 : <...> SYSALLOC Bloc 003D24D8 freed at line 66 of 'liste.c' not allocated SYSALLOC Bloc 003D24C8 (8 bytes) malloc'ed at line 73 of 'liste.c' not freed SYSALLOC Bloc 003D24E8 (8 bytes) malloc'ed at line 73 of 'liste.c' not freed
Tu me fais un malloc() dans retirer() ? Pourquoi ? C'est le dernier endroit où on doit voir du malloc(). Du free(), oui, mais certainement pas de malloc().

Et quand il n'y a plus qu'un seul élément, tu fais deux free() ! Il y en a forcément un de trop, puisque il ne reste plus qu'un élément !

Voir 40 message(s) de cette discussion en une page