liste doublement chainée circulaire

Version imprimable

bonjour,
J'essaie de faire une liste doublement chainée circulaire mais sa seg fault dès que je l'affiché.. :(
Donc, ma structure est celle ci:

Code:

1
2
3
4
5
6
7
typedef struct          s_arguments
{
  char                  *str;
  int                   select;
  struct s_arguments    *nxt;
  struct s_arguments    *prv;
}                       t_arguments;

et le code l'utilisant est celui ci:

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
t_arguments     *add_elem(t_arguments *first, t_arguments *cur, char *str)
{
  t_arguments   *new_elem;
 
  new_elem = my_malloc(sizeof(*new_elem));
  new_elem->str = my_strdup(str);
  new_elem->select = 0;
  new_elem->prv = first;
  new_elem->nxt = cur;
  return (new_elem);
}
 
t_arguments     *sort_in_list(int ac, char **av)
{
  int           i;
  t_arguments   *my_arg;
  t_arguments   *new_elem;
 
  i = 1;
  my_arg = 0;
  new_elem = my_arg;
  while (i < ac)
    {
      new_elem = add_elem(my_arg, new_elem, av[i]);
	new_elem = new_elem->nxt;
      i++;
    }
  my_putstr(my_arg->str);
  return (my_arg);
}

03/12/2008, 16h27
Médinoc

Ta fonction d'insertion entre deux éléments ne modifie pas lesdits éléments, alors qu'elle devrait (s'ils sont présents).

ha bon? Je ne les modifie pas, je veux juste les stocker (a propos se sont les arguments passé à mon programme :-))
Merci pour ta réponse.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 t_arguments *sort_in_list(int ac, char **av) { int i; t_arguments *my_arg; t_arguments *new_elem; i = 1; my_arg = 0; new_elem = my_arg; while (i < ac) { new_elem = add_elem(my_arg, new_elem, av[i]); printf("%s\n", new_elem->str); new_elem = new_elem->nxt; i++; } return (my_arg); }
tout les élements s'affiche bien... :'(

03/12/2008, 16h42
diogene
sort_in_list(...)
my_arg est mis au début à NULL (c'est préférable d'écrire NULL plutôt que 0).
La fonction ne modifie jamais my_arg, qui est encore à NULL en arrivant à

Code:

my_putstr(my_arg->str);

qui tente de déréférencer un pointeur NULL -> plantage.
Code:

1 2 3 4 5 6 while (i < ac) { new_elem = add_elem(my_arg, new_elem, av[i]); new_elem = new_elem->nxt; i++; }
La première fois qu'on entre dans le while, my_arg et new_elem sont à NULL.
add_elem crée alors un élément dont les pointeurs nxt et prev sont à NULL.
Ceci remet new_elem à NULL !!!

A remarquer que add_elem n'insère pas correctement dans la liste puisqu'elle ne modifie pas les pointeurs first->nxt et cur->prv.
03/12/2008, 16h43
Médinoc

Ta fonction d'ajout doit modifier les pointeurs prev et next des chaînons qui "touchent" le nouvel élément.
03/12/2008, 16h49
Maf77
Lol Médinoc ;) ta remarqué la non présence des "e" :P

Donc, je pensais ne pas modifié First du aufaite que mon dernier élément devra pointé sur le 1er, c'est pour cela que je ne modifie pas first.
Ensuite, pour l'élement courant, je devrais modifié son pointeur prev? :roll:

Citation:

Envoyé par diogene

sort_in_list(...)
my_arg est mis au début à NULL (c'est préférable d'écrire NULL plutôt que 0).
La fonction ne modifie jamais my_arg,

Et ma ligne:
Code:

1 2 my_arg = NULL; new_elem = my_arg;
Elle sert à sauvegardé le 1er élement de ma liste pour ensuite renvoyé la liste dans le bon ordre (1er au dernier)

Typiquement, pour une liste doublement chaînée, on insère un élément comme ça:

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
typedef struct s_chainon
{
	struct s_chainon *pNext;
	struct s_chainon *pPrev;
 
	/*contenu*/
	/*...*/
} t_chainon;
 
typedef struct s_liste
{
	t_chainon *pFirst;
	t_chainon *pLast;
};
 
void InsererAvant(t_chainon *pAvantQuoi, t_chainon *pNew)
{
	assert(pAvantQuoi != NULL);
	assert(pNew != NULL);
	assert(pNew->pPrev==NULL);
	assert(pNew->pSuiv==NULL);
 
	/*Règle les pointeurs de pNew*/
	pNew->pNext = pAvantQuoi;
	pNew->pPrev = pAvantQuoi->pPrev;
	/*Règle les pointeurs devant pointer sur pNew*/
	pAvantQuoi->pPrev = pNew;
	if(pNew->pPrev != NULL)
	{
		assert(pNew->pPrev->pNext == pAvantQuoi);
		pNew->pPrev->pNext = pNew;
	}
}
 
void InsererApres(t_chainon *pApresQuoi, t_chainon *pNew)
{
	assert(pApresQuoi != NULL);
	assert(pNew != NULL);
	assert(pNew->pPrev==NULL);
	assert(pNew->pSuiv==NULL);
 
	/*Règle les pointeurs de pNew*/
	pNew->pPrev = pApresQuoi;
	pNew->pNext = pApresQuoi->pnext
	/*Règle les pointeurs devant pointer sur pNew*/
	pApresQuoi->pNext = pNew;
	if(pNew->pNext != NULL)
	{
		assert(pNew->pNext->pPrev == pApresQuoi);
		pNew->pNext->pPrev = pNew;
	}
}
 
void InsererEnTete(t_liste *pListe, t_chainon *pNew)
{
	assert(pListe != NULL);
	assert(pNew != NULL);
 
	if(pListe->pFirst == NULL)
	{
		pListe->pFirst = pNew;
		pListe->pLast = pNew;
		/* Rend circulaire la liste */
		pNew->pPrev = pNew;
		pNew->pNext = pNew;
	}
	else
	{
		InsererAvant(pListe->pFirst, pNew);
		pListe->pFirst = pNew;
	}
}
 
void InsererEnQueue(t_liste *pListe, t_chainon *pNew)
{
	assert(pListe != NULL);
	assert(pNew != NULL);
 
	if(pListe->pLast == NULL)
	{
		pListe->pFirst = pNew;
		pListe->pLast = pNew;
		/* Rend circulaire la liste */
		pNew->pPrev = pNew;
		pNew->pNext = pNew;
	}
	else
	{
		InsererApres(pListe->pLast, pNew);
		pListe->pLast = pNew;
	}
}