Discussion :

[Maf77]

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 :

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

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 :

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
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);
}

[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).

[Maf77]

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 :

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
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... :'(

[Médinoc]

Ta fonction d'ajout doit modifier les pointeurs prev et next des chaînons qui "touchent" le nouvel élément.

[Maf77]

Lol Médinoc ta remarqué la non présence des "e"

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?

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 :

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

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)

[Médinoc]

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

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
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;
	}
}

[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 :

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

my_putstr(my_arg->str);

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

Code :

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

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.