Discussion :

[med_alpa]

j'ai une liste chainée avec comme valeur une chaine de caractère.

Code :

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

1
2
3
4
5
6
7
8
9
typedef struct Liste
 
{
 
     char *valeur;
 
     struct Liste *suivant;
 
} Liste ;

j'ai une fonction ajouter

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
 
 
void ajouter(Liste **sl, char* Val)
 
{
 
        Liste *tmp = NULL;
 
        Liste *csl = *sl;
 
        Liste *elem = (Liste*)malloc(sizeof(Liste));
 
        if(!elem) exit(EXIT_FAILURE);
	//strcpy(elem->valeur,Val);
 
        //elem->valeur=malloc(strlen(Val)*sizeof(char));
 
        //strcpy(elem->valeur,res);
 
	elem->valeur=Val;        
	elem->suivant=NULL;
 
        while(csl)
 
        {
 
             tmp = csl;
 
             csl = csl->suivant;
 
        }
 
 
 
        if(tmp) 
 
             tmp->suivant = elem;
 
 
 
        else {
 
             *sl = elem;
 
        }
 
}

le problème c'est que si j'alloue de la memeoire pour la chaine de caractère dans cette fonction je recoit une erreur de sementation.

et si j'enlève l'allocation il n'y a pas d'erreur mais le problème c'est que j'appelle la fonction ajouter plusieurs fois et si je garde l'affectation de la chaine de caractère je vais me retrouver avec tous les elements de liste pointé sur une meme chaine null.

[med_alpa]

Cette meme erreur est rencontré lorsque je test

Code :

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

if(*lst==NULL)

sachant que lst est de type

Code :

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

 Liste ** lst

[diogene]

Tu dois allouer de la mémoire pour la chaine, mais si je me fie à ce que tu as mis en commentaires, tu n'en alloues pas assez :

Code :

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

1
2
3
4
5
elem->valeur=malloc(strlen(Val)+1);
if(elem->valeur != NULL)
{
   strcpy(elem->valeur,Val); 
   .....

[Sve@r]

Code c :

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

1
2
3
4
5
6
void ajouter(Liste **sl, char* Val)
{
...
	elem->valeur=Val;        
...
}

Pas bon. Là, tu ne stockeras que le pointeur de la zone passée à la fonction. Et si cette zone est, de son coté, une simple zone de travail et/ou de transit, tu ne stockeras que du vent...

Accessoirement, comme je dis assez souvent ici, je préconise toujours de définir une structure spéciale pour gérer la liste en plus de la structure de gestion d'un élément de la liste. Ca peut paraitre stupide de définir une structure "s_liste" qui ne contiendra à priori que le premier élément de cette liste mais ça permet ensuite d'y rajouter facilement d'autres trucs (comme par exemple le nombre d'éléments) sans avoir à tout reprendre et surtout, ça évite ainsi le double étoile dans Liste **sl qui, éviidemment, s'impose quand le premier élément change.

C'est un peu comme une chemise. On peut très bien tenir une chemise par le col. Mais si on la met sur un cintre, ça permet quand-même de mieux la manipuler...

Voici donc un exemple type de ce que j'aurais écrit

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
typedef struct s_elem {
	char *valeur;
	struct s_elem *suivant;
} t_elem;
 
typedef struct {
	t_elem *first;
} t_liste;
 
t_elem* ajouter(t_liste *liste, char* Val)
{
	t_elem *elem;
	t_elem *inf;
        t_elem*sup;
 
	// Allocation et remplissage
	elem=malloc(sizeof(t_elem));
	if(!elem) return NULL;   // Ne jamais sortir par exit d'une fonction, toujours renvoyer le pb à l'appelant qui est seul habilité à décider de l'action à faire...
 
	elem->valeur=malloc(strlen(Val) + 1);
	if (elem->Valeur == NULL)
	{
		free(elem);
		return NULL;
	}
	strcpy(elem->valeur, val);
 
	// Recherche éléments encadrant l'élément à insérer
	for (inf=NULL, sup=liste->first; sup != NULL && strcmp(Val, sup->valeur) > 0; inf=sup, sup=sup->next);
 
	// A partir d'ici, 4 possibilités
	// 1) La liste est vide => sup vaut NULL et elem étant le premier doit avoir son next à NULL
	// 2) L'élément s'insère en premier => sup vaut alors liste->first et elem étant le premier doit avoir son next pointant vers ce liste->first qui deviendra second
	// 3) L'élément s'insère au milieu => sup vaut la valeur de celui qui le suit et elem doit avoir son next vers cet élément là
	// 4) L'élément s'insère en dernier => sup vaut NULL et elem doit avoir son next sur NULL
	// Conclusion: dans tous les cas, sup a la valeur qui convient à chaque cas
	elem->next=sup;
 
	// Cas le plus général: l'élément se met au milieu (ou en fin) de liste. Dans ce cas, inf est forcément placé avant elem et a donc une valeur non nulle
	if (inf != NULL) 
	{
		// Il n'y a donc qu'à positionner son pointeur
		inf->next=elem;
	}
	else
	{
		// On est dans le cas particulier où elem est le premier élément de la liste
		// On change donc simplement ce premier élément qu'on place sur elem
		liste->first=elem;
	}
 
	// On renvoie une valeur juste pour ne pas renvoyer NULL
	return elem;
}

[med_alpa]

Merci pour vos réponses.