Discussion :

[sorry60]

Bonjour,

Suite à mon autre post, je me relance dans les listes simplement chaînées...
J'ai le fameux "erreur de segmentation", ce qui veut dire que j'accede à une zone de mémoire qui n'est pas pour mon programme, ceci probablement du à un mauvais usage d'un pointeur...

J'ai cherché jusqu'à très tard hier mais j'ai pas trouvé l'erreur
L'erreur intervient sur la fonction un élément :
Voici la structure :

Code :

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

1
2
3
4
5
6
7
8
 
typedef struct client
	{
		char *login;
		char *passwd;
		int fd;
		struct client *suivant;
	} client;

Voici la fameuse fonction qui déraille :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
void ajouter_client (client** p, char log[16], char mdp[16], int fd)
{
	client* new = malloc(sizeof (client));
 
	new->login = log;
	new->passwd = mdp;
	new->fd = fd;
	new->suivant = NULL;
	(*p)->suivant = new;
}

Son appel dans le main :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
#include "liste.h"
#include <stdio.h>
 
int main()
{
	client *mes_clients = NULL;
 
	ajouter_client(&mes_clients,"momo","toto",5);
 
	return 0;
}

J'espere que vous aurez des meilleurs yeux que moi !
Merci pour vos réponses
Sorry

[AxldenieD]

Voici la fameuse fonction qui déraille :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
void ajouter_client (client** p, char log[16], char mdp[16], int fd)
{
	client* new = malloc(sizeof (client));
 
	new->login = log;
	new->passwd = mdp;
	new->fd = fd;
	new->suivant = NULL;
	(*p)->suivant = new;
}

Son appel dans le main :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
#include "liste.h"
#include <stdio.h>
 
int main()
{
	client *mes_clients = NULL;
 
	ajouter_client(&mes_clients,"momo","toto",5);
 
	return 0;
}

J'espere que vous aurez des meilleurs yeux que moi !
Merci pour vos réponses
Sorry

Alors je peux me tromper mais :
tu passes en paramètre l'adresse de mes_clients
la valeur associé à cette adresse est NULL (variable initialisé comme ça)

Code :

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

(*p)->suivant = new;

donc là (*p) est NULL donc (*p)->suivant n'existe pas donc "segmentation fault"

ce qu'il faudrait mettre serais plutot

Code :

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

(*p)=new;

bien sur il faut à la base faire untest sur ton pointeur si il est NULL alors tu affecte simplement la valeur sinon tu affescte la valeur à *p->suivant

voila

en esperant ne pas m'être trompé

[Jack_serious]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
void ajouter_client (client** p, char log[16], char mdp[16], int fd)
{
	client* new = malloc(sizeof (client));
 
	new->login = log;
	new->passwd = mdp;
	new->fd = fd;
	new->suivant = NULL;
	(*p)->suivant = new;
}

Sinon pour eviter d'avoir a faire un test lors de l'insersion dans une liste chainee, le plus simple c'est (pardonnez moi mon pere) d'enfiler par l'avant :

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
48
49
50
51
 
#include <stdio.h>
#include <stdlib.h>
 
typedef struct 	client
{
  char *login;
  char *passwd;
  int fd;
  struct client *suivant;
}	       	client;
 
void		ajouter_client (client** p, char log[16], char mdp[16], int fd)
{
  client*	new;
 
  new = malloc(sizeof(*new));
  new->login = log;
  new->passwd = mdp;
  new->fd = fd;
  new->suivant = *p;                                  // tu places ton nouvel element devant l'actuel premier
  *p = new;                                                 // il devient l'actuel premier
  return;
}
 
int			display_list(client *list)
{
  client		*current;
 
  current = list;
  while (current)
    {
      printf("%s, %s\n", current->login, current->passwd);
      current = current->suivant;
    }
  return (0);
}
 
int			main(void)
{
   client		*mes_clients;
 
   mes_clients = NULL;
   ajouter_client(&mes_clients,"Momo", "Toto",5);
   ajouter_client(&mes_clients,"Delphine", "Talaron", 42);
   ajouter_client(&mes_clients,"His_log", "His_passwd", 21);
   ajouter_client(&mes_clients,"The_fourth_one", "xxxx", 84);
   ajouter_client(&mes_clients,"Last", "youwillneverfindit", 31415);
   display_list(mes_clients);
   return (0);
}

[Trap D]

Soit on ajoute en tête comme le propose Jack_serious soit on ajoute en queue et là, il faut défiler toute la liste pour arriver au dernier éléement (celui ou ->suivant = NULL sinon on perd des infos.

[sorry60]

Soit on ajoute en tête comme le propose Jack_serious soit on ajoute en queue et là, il faut défiler toute la liste pour arriver au dernier éléement (celui ou ->suivant = NULL sinon on perd des infos.

Ok donc en fait, j'ai fait n'importe quoi hier soir...
Je m'y recolle !

[sorry60]

J'ai rectifié et commenté mes 3 fonctions.
J'ai testé, elles ont l'air correctes mais je les poste quand même car vous avez surement des critiques à faire

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
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
 
#include "liste.h"
#include <stdio.h>
#include <stdlib.h>
 
/* ********************************************************************************** */
void ajouter_client (client** p, char log[16], char mdp[16], int fd)
{
   /* on créé un client à ajouter */
   client* new = malloc(sizeof (client));
 
   if ( new )
   {
	   /* on remplit ses champs */
	   new->login = log;
	   new->passwd = mdp;
	   new->fd = fd;
	   new->suivant = *p;
	   /* on le place en debut de liste */
	   *p = new;
        }
   else
   {
      perror("malloc()");
   }
} 
/* ********************************************************************************** */
void retirer_client(client **p,int fd)
{
   client *prec = malloc(sizeof (client));
 
   if ( prec )
   {
	   /* si la liste est vide */
	   if ( !p )
	   {
              /* rien à faire...*/
              return;
	   }
	   /* si la liste ne contient qu'un seul élément */
	   if ( !((*p)->suivant) )
	   {
              /* on libère l'element */
              free(*p);
              /* on fait pointé la liste sur NULL */
              p = NULL;
              return;
           }
           /* sinon on parcourt la liste jusqu'au bon client*/
           while ( p && ((*p)->fd != fd) )
           {
              /* on sauvegarde l'element precédent */
              prec = *p;
              /* on passe au client suivant */
              *p = (*p)->suivant;
           }
           /* on saute l'element bientot supprimé */
           prec->suivant = (*p)->suivant;
           /* on supprime l'element */
           free(*p);
           /* le client precedent devient le client actuel */
           *p = prec;
        }
   else
   {
      perror("malloc()");
   }
}	
/* ********************************************************************************** */
void afficher_clients(client *p)
{
	/* on parcourt la liste tant qu'il y a un client */
	while (p)
	{
		/* on affiche le champ du login de chaque client */
		puts(p->login);
		/* on pointe sur le client suivant */
		p = p->suivant;
	}
}
/* ********************************************************************************** */

Merci pour vos critiques
Sorry

[Emmanuel Delahaye]

J'ai rectifié et commenté mes 3 fonctions.
J'ai testé, elles ont l'air correctes mais je les poste quand même car vous avez surement des critiques à faire

Ne jamais oublier que malloc() peut echouer.

[sorry60]

J'ai rectifié et commenté mes 3 fonctions.
J'ai testé, elles ont l'air correctes mais je les poste quand même car vous avez surement des critiques à faire

Ne jamais oublier que malloc() peut echouer.

Oui c'est vrai, je vais rectifer de suite.
A part ça c'est ok ?

Edit : c'est fait pour malloc

[Emmanuel Delahaye]

J'ai rectifié et commenté mes 3 fonctions.
J'ai testé, elles ont l'air correctes mais je les poste quand même car vous avez surement des critiques à faire

Ne jamais oublier que malloc() peut echouer.

Oui c'est vrai, je vais rectifer de suite.
A part ça c'est ok ?

Manque la libération...

[sorry60]

Manque la libération...

La voici :

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
 
/* ********************************************************************************** */
void clear_clients(client **p)
{
	client* tmp = malloc(sizeof (client));
	if (tmp)
	{
		/* on parcourt la liste tant qu'il y a un client */
		while((*p)->suivant)
		{
			tmp = (*p)->suivant;
			/* on libère la mémoire occupée par un client */
			free(*p);
			(*p) = tmp;
		}
		free(*p);
	}
	else
	{
		perror("malloc()");
	}
}
/* ********************************************************************************** */

[Emmanuel Delahaye]

Manque la libération...

La voici :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
void clear_clients(client **p)
{
	client* tmp = malloc(sizeof (client));
	if (tmp)
	{
		/* on parcourt la liste tant qu'il y a un client */
		while((*p)->suivant)
		{
			tmp = (*p)->suivant;

??? Je ne comprend pas à quoi cert cette allocation.

Qu'est-ce qui ne va pas avec

Code :

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

1
2
3
4
5
6
7
 
void clear_clients(client **p)
{
   /* on parcourt la liste tant qu'il y a un client */
   while((*p)->suivant)
   {
      client* tmp = (*p)->suivant;

[sorry60]

Qu'est-ce qui ne va pas avec

Code :

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

1
2
3
4
5
6
7
 
void clear_clients(client **p)
{
   /* on parcourt la liste tant qu'il y a un client */
   while((*p)->suivant)
   {
      client* tmp = (*p)->suivant;

Oui c'est vrai...

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
 
/* ********************************************************************************** */
void clear_clients(client **p)
{
	/* on parcourt la liste tant qu'il y a un client */
	while((*p)->suivant)
	{
		client* tmp = (*p)->suivant;
		/* on libère la mémoire occupée par un client */
		free(*p);
		(*p) = tmp;
	}
	free(*p);
}
/* ********************************************************************************** */

Maintenant, all is ok ?

[Emmanuel Delahaye]

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
 
/* ********************************************************************************** */
void clear_clients(client **p)
{
	/* on parcourt la liste tant qu'il y a un client */
	while((*p)->suivant)
	{
		client* tmp = (*p)->suivant;
		/* on libère la mémoire occupée par un client */
		free(*p);
		(*p) = tmp;
	}
	free(*p);
}
/* ********************************************************************************** */

Maintenant, all is ok ?

Je ne sais pas ce qu'est un 'client'. Dans une liste chainée, il y a des 'noeuds' (nodes). Ce sont les noeuds que l'on alloue, lie, délie et libère.

Je pense que ce que tu appelles 'client' et en réalité une structure de données applicative. Il y a peut être des choses à libérer dedans aussi...

J'utilise une liste chainée comme ça :

Code :

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

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

avec

Code :

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

1
2
3
4
5
6
7
 
struct node
{
   struct node *p_next;
   struct node *p_prec; /* si doublement chainee */
   void *p_data;
};

Le code qui gère tout ça peut être unique quelque soient les données...
Il suffit de créer les fonctions qui vont bien et de préciser les regles du jeu (les données doivent avoir une duréede vie >= aux noeuds de la chaine...)

[sorry60]

Un client est un typedef struct :

Code :

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

1
2
3
4
5
6
7
8
 
typedef struct client
   {
      char *login;
      char *passwd;
      int fd;
      struct client *suivant;
   } client;

[Jack_serious]

Personnellement pour liberer une liste chainee dans sa globalite, j'utilise la recursivite :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
#include <stdlib.h>
 
int             free_list(t_elem *elem)
{
  if (elem->next)
    free_list(elem->next);
  free(elem->data);
  free(elem);
  return (0);
}

Note : deconseille si la liste contient quelques millions d'elements. Avec la recursivite on risque toujours de faire sauter sa pile.

[Emmanuel Delahaye]

Un client est un typedef struct :

Code :

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

1
2
3
4
5
6
7
8
 
typedef struct client
   {
      char *login;
      char *passwd;
      int fd;
      struct client *suivant;
   } client;

Ce qui me gène, c'est le mélange entre les données 'liste' et les données applicatives. Je préconise

Code :

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

1
2
3
4
5
6
7
 
struct client
{
   char *login;
   char *passwd;
   int fd;
};

d'une part, et une structure de liste (node) comme préconisée ci-dessus...

[sorry60]

Code :

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

1
2
3
4
5
6
7
 
struct node
{
   struct node *p_next;
   struct node *p_prec; /* si doublement chainee */
   void *p_data;
};

Moi ce qui me gêne c'est que je ne maitrise pas le type void..

[Emmanuel Delahaye]

Moi ce qui me gêne c'est que je ne maitrise pas le type void..

Il n'y a rien à maitriser. Il suffit d'être réveillé, c'est tout.

[sorry60]

Il n'y a rien à maitriser. Il suffit d'être réveillé, c'est tout.

Ok je vais voir ce que ça donne
Mais je vois pas comment (avec ton systeme) enlever un élément precis d'une liste (dans mon cas, le client qui s'appelle "toto" par exemple..)

[sorry60]

Les prototypes des fonctions seraient comme ça :

Code :

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

1
2
3
 
void ajouter_element(list **p_list,void *p_data);
void retirer_element(list **p_list,void data);

: :