Suppression élément d'une Liste

Bonjour,

Est-ce que quelqu'un pourrait m'aider ? :)
J'ai mon code qui devrait supprimer un élément de ma liste sauf qu'au lieu de le supprimer il le modifie avec des caractère "bizarre" :)
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 void FreeGenre(PGENRE_NEW pGenre) { PGENRE_NEW pPrev = FindPrevSibblingGenre(pGenre); PGENRE_NEW pNext = pPrev == NULL ? NULL : pPrev->pNext; if (pGenre->pszNom) free(pGenre->pszNom); free(pGenre); pGenre = NULL; if (pPrev != NULL) pPrev->pNext = pNext; if (pPrev == NULL) pRootGenre = NULL; }
Merci de votre aide

pRootGenre est une variable globale? Tu devrais la préfixer de g_ pour bien l'indiquer.

Oui

PGENRE_NEW pRootGenre = NULL;

Et PGENRE_NEW correspond à ça :

Code:

1
2
3
4
5
6
7
8
9
 
typedef struct
{
    int                 nId;        /* Id du genre*/
    char*               pszNom;     /* Nom du genre*/
    struct GENRE_NEW*   pNext;      /* Pointeur sur le prochain genre*/
} GENRE_NEW;
 
typedef GENRE_NEW* PGENRE_NEW;

Franchement, je réfléchis mieux en terme de "quel est le pointeur à modifier" plutôt qu'en terme de "précédent".
Observe:

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
//À partir du pointeur sur un objet,
//Retourne un pointeur sur l'objet suivant
PGENRE_NEW GetNext(PGENRE_NEW pObj) { return pObj->pNext; }
 
//À partir d'un pointeur vers le pointeur sur un objet dans la liste,
//Retourne un pointeur vers le pointeur sur l'objet suivant.
PGENRE_NEW *GetPtrNext(PGENRE_NEW *ppObj) { return &( (*ppObj)->pNext ); }
 
//Trouve objet, retourne directement un pointeur dessus
PGENRE_NEW FindGenre(PGENRE_NEW pFirst, int nId)
{
	PGENRE_NEW pCurrent;
	for(pCurrent=pFirst ; pCurrent!=NULL ; pCurrent = GetNext(pCurrent))
	{
		if(pCurrent->nId == nId)
			return pCurrent;
	}
	return NULL;
}
 
//Trouve objet, retourne un pointeur vers son pointeur dans la liste.
PGENRE_NEW * FindPtrGenre(PGENRE_NEW *ppFirst, int nId)
{
	PGENRE_NEW *ppCurrent;
	for(ppCurrent=ppFirst ; (*ppCurrent)!=NULL ; ppCurrent = GetPtrNext(pCurrent))
	{
		if((*ppCurrent)->nId == nId)
			return ppCurrent;
	}
	return NULL;
}

Là où GetNext() et FindGenre() retournent un pointeur vers l'objet, GetNextPtr() et FindPtrGenre() retournent un pointeur vers le pointeur de l'objet dans la liste. Ce qui signifie que si l'objet trouvé est le premier objet, la fonction retournera directement l'adresse de pRootGenre.

On peut alors trouver un objet, le retirer de la liste, et le détruire séparément:

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
//Retire un objet de la liste (mais sans le détruire),
//à partir d'un pointeur vers son pointeur dans la liste
PGENRE_NEW Detach(PGENRE_NEW *ppObj)
{
	PGENRE_NEW pObj = *ppObj;
	*ppObj = pObj->pNext;
	//Le pointeur qui pointait sur l'objet pointe maintenant sur l'objet suivant.
	//L'objet n'est donc plus dans la liste.
 
	pObj->pNext = NULL;
	return pObj;
}
 
//Détruit un objet Genre et libère ses ressources
void DestroyGenre(PGENRE_NEW pDel)
{
	free(pDel->pszNom);
	pDel->pszNom = NULL;
	free(pDel);
}
 
//Trouve un objet Genre, le retir de la liste et le détruit
void DeleteGenreById(int nId)
{
	PGENRE_NEW * ppGenreToDelete = FindPtrGenre(&pRootGenre, nId);
	if(ppGenreToDelete != NULL && *ppGenreToDelete != NULL)
	{
		PGENRE_NEW pDel = Detach(ppGenreToDelete);
		DestroyGenre(pDel);
	}
}

Et ça marche aussi pour les insertions: Si tu mémorises un pointeur vers le dernier pointeur de la liste (celui qui est nul), tu peux directement ajouter des objets en fin de liste:

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
PGENRE_NEW * GetPtrAfterLastGenre(PGENRE_NEW *ppFirst)
{
	PGENRE_NEW *ppCurrent;
	for(ppCurrent=ppFirst ; (*ppCurrent)!=NULL ; ppCurrent = GetPtrNext(pCurrent))
	{ }
	//Ici, ppCurrent pointe sur un pointeur nul.
	return ppCurrent;
}
 
void Insert(PGENRE_NEW *ppWhere, PGENRE_NEW pNew)
{
	pNew->pNext = *ppWhere;
	*ppWhere = pNew;
}
 
void InsertHead(PGENRE_NEW pNew)
{
	Insert(&pRootGenre, pNew);
}
void AppendTail(PGENRE_NEW pNew)
{
	Insert(GetPtrAfterLastGenre(&pRootGenre), pNew);
}
 
//Exemple qui ajoute chaque élément à la fin, en boucle,
//de manière efficace (on ne re-parcoure pas toute la liste à chaque fois)
void BuildList()
{
	PGENRE_NEW pNew = NULL;
	PGENRE_NEW *ppAfterLast = GetPtrAfterLastGenre(&pRootGenre);
 
	//Ici, ReadGenre() est ta fonction qui crée un nouveau genre depuis un fichier, 
	//une entrée utilisateur, etc. On suppose qu'elle retourne NULL quand il n'y a plus rien à mettre dans la liste.
	while((pNew=ReadGenre()) != NULL)
	{
		Insert(ppAfterLast, pNew);
		ppAfterLast = GetPtrNext(ppAfterLast);
	}
}

S'il y a des parties que tu ne comprends pas, n'hésite pas à poser des questions.