Discussion :

[Genesis]

tu as raison ca vient surement de nom, quand j'essaie de l'afficher j'ai la même erreur.

je recupere ma chaine de caracteres comme ceci:

Code :

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

1
2
3
4
5
 
 
char pseudo[256];
nbytes=recv(newfd,pseudo,sizeof(pseudo)-1,0);
pseudo[nbytes]='\0';

puis je la passe à mon fonction ajoutListe:

Code :

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

statut=ajoutListe(&l, newfd, pseudo);

et ma fonction ajoutListe:

Code :

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

int ajoutListe(struct listeClients **l, int sock, char *nom)

et...je ne vois pas pourquoi nom ne pointerait pas vers mon tableau de caracteres...

[Skyounet]

Et si tu affiches juste après le recv ca fonctionne ? Tu le modifies pas entre le recv et ton appel de fonction ?

[Emmanuel Delahaye]

mais il n'y a rien à faire j'ai un "segmentation fault" et je ne vois pas mon erreur...si qqun pouvait m'orienter

Il y a un problème avec la copie. Je ne sais pas pourquoi tu fais un truc aussi compliqué...

Code :

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

memcpy(nouveau->pseudo, nom, strlen(nouveau->pseudo));

qui n'a aucune chance de fonctionner vu que strlen() ne fonctionne que sur une chaine valide (les données allouées par malloc() sont indéfinies) : comportement indéfini, tout peut arriver.

Ceci fonctionne. On peut le sécuriser.

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
82
83
84
85
86
87
 
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
 
struct listeClients
{
   /* données */
   int socket;
   char pseudo[256];
   /* chainage */
   struct listeClients *suivant;
};
 
struct listeClients *ajoutListe (struct listeClients *l, int sock, char *nom)
{
   /* allocation du noeud */
   struct listeClients *nouveau = malloc (sizeof *nouveau);
 
   /* si tout c'est bien passe : */
   if (nouveau != NULL)
   {
      /* mise a jour des champs : */
 
      /* donnees */
      nouveau->socket = sock;
      strcpy (nouveau->pseudo, nom);
      /* chainage par defaut */
      nouveau->suivant = NULL;
 
      /* chainage */
      if (l == NULL)
      {
         /* c'est le premier : */
         l = nouveau;
      }
      else
      {
         /* on cherche le dernier noeud */
         struct listeClients *p = l;
 
         while (p->suivant != NULL)
         {
            /* pointer sur le suivant */
            p = p->suivant;
         }
 
         /* modification du chainage */
         p->suivant = nouveau;
      }
   }
   return l;
}
 
void afficheListe (struct listeClients const *l)
{
   struct listeClients const *p = l;
   while (p != NULL)
   {
      printf ("%d : '%s'\n", p->socket, p->pseudo);
      /* pointer sur le suivant */
      p = p->suivant;
   }
}
 
#include <unistd.h>
 
int main (void)
{
 
   struct listeClients *l = NULL;
   int newfd = STDIN_FILENO;
   char pseudo[32];
 
   do
   {
 
      int nbytes = read (newfd, pseudo, sizeof pseudo - 1);
      pseudo[nbytes] = 0;
      l = ajoutListe (l, newfd, pseudo);
   }
   while (pseudo[0] != '\n');
 
   afficheListe (l);
 
   return 0;
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
zebulon
pollux
 
0 : 'zebulon
'
0 : 'pollux
'
0 : '
'
 
Press ENTER to continue.

[Emmanuel Delahaye]

Code :

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

1
2
3
4
5
6
7
8
struct listeClients 
{	
	/* données */
	int socket;
	char *pseudo;
	/* chainage */
	struct listeClients * suivant ;
};

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
int ajoutListe(struct listeClients **l, int sock, char *nom)
{
	/* allocation du noeud */
	struct listeClients *nouveau = malloc (sizeof *nouveau);
 
   /* si tout c'est bien passe : */
	if (nouveau != NULL) {
      /* mise a jour des champs : */
 
      /* donnees */
		nouveau->socket = sock;
		strcpy(nouveau->pseudo, nom);

pseudo est un pointeur non initialisé. Le comportement est indéfini. J'ai posté du code qui fonctionne.

[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
 
struct listeClients 
{	
	/* données */
	int socket;
	char pseudo[256];
	/* chainage */
	struct listeClients * suivant ;
};
 
...
 
strncpy(nouveau->pseudo, nom, sizeof(nom));

Attention. Il ne faut pas utiliser strncpy() si on ne maitrise pas.

Je conseille :

Code :

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

1
2
3
 
   nouveau->pseudo[0] = 0; /* "" */
   strncat(nouveau->pseudo, nom, sizeof nouveau->pseudo - 1);

[Emmanuel Delahaye]

comme ca c'est bon:

Code :

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

nouveau->pseudo=malloc(sizeof(nom));

d'ailleurs dans ma structure je devrais utilisé un pointeur sur chaine de caracteres ou un tableau de caracteres suffit?

Si tu tiens au pointeur, le plus simple est :

Code :

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

nouveau->pseudo = strdup(nom));

C'est POSIX.1, donc très portable, et c'est fait pour...

Penser à libérer le bloc quand on en a plus besoin (free()).

[diogene]

Souviron34 :

Code :

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

1
2
3
4
5
6
7
8
9
10
struct listeClients * ajoutListe(struct listeClients *l, int sock, char *nom)
{
....

		if (l == NULL){
         		/* c'est le premier : */
         		l = nouveau;    /* la déclaration de l n'en fait pas un pointeur modifiable */		}
....
	return l; /* ici l est inchangé */   
}

Je ne comprend pas pourquoi tu dis cela (en commentaires).

[souviron34]

parce que dans cette version (ta première) l est uniquement déclaré un pointeur...

Quand tu fais "l = quelque chose", tu le modifies localement (ça marche, mais c'est très très très fortement à déconseiller), mais quand tu ressors de la routine, la valeur n'est pas modifiée, car (à part le return) le passage en entrée par simple pointeur fait que tu ne peux à l'extérieur de la fonction récupérer la valeur modifiée, d'où mon conseil de double pointeur.

Ensuite, retourner en résultat de fonction une valeur entrée en paramètre comme non-modifiable (voir ci-dessus) modifiée localement est plus que de la haute voltige.. Je dirais même à comportement indéterminé... Et certainement non seulement à déconseiller, mais à éviter à tout prix...

[diogene]

souviron34

parce que dans cette version (ta première) l est uniquement déclaré un pointeur...

Ce n'est pas ma première mais celle de l'auteur du message

Quand tu fais "l = quelque chose", tu le modifies localement

bien sur

(ça marche, mais c'est très très très fortement à déconseiller),

?

mais quand tu ressors de la routine, la valeur n'est pas modifiée, car (à part le return)

mais il y a un return dans ce code

...d'où mon conseil de double pointeur.

Personnellement, je préfère aussi cette solution

Ensuite, retourner en résultat de fonction une valeur entrée en paramètre comme non-modifiable (voir ci-dessus) modifiée localement est plus que de la haute voltige.. Je dirais même à comportement indéterminé...

?

[souviron34]

Ce n'est pas ma première mais celle de l'auteur du message

Excuse-moi je n'avais pas remarqué...

Quand tu fais une modification locale d'un paramètre non-modifiable, tu modifies la copie locale. Donc oui ça marche. Mais ce n'est vraiment pas recommandé, puisque contrairement à l'ancien Fortran, il y a en C la possibilité de passer des variables modifiables ou non-modifiables.

Si tu veux modifier une variable, il est recommandé , puisque c'est la base des déclarations de variables en C, de s'arranger pour que la déclaration dans l'appel tienne compte de cette possibilité (et donc passer un pointeur).

Donc si c'est un pointeur, passer l'adresse du pointeur (**l) et non le pointeur.

Quant au dernier point, non seulement c'est dangereux , non recommandé, hors norme, et tout ce que tu veux dans ce sens, mais suivant le style de chose et d'usage potentiellement fatal.. [car quelqu'un qui programme comme ça fait nécessairement des choses aussi peu claires ailleurs]. Et totalement non nécessaire, puisque le langage fourni une manière simple de faire ça. Et si ce qu'on veut ce n'est pas modifier le paramètre entré, eh bien on prend une autre variable locale dans laquelle on recopie le paramètre...

Si j'étais prof, je mettrais 0 à toute personne utilisant cela...


[EDIT]

De plus, autant faire " l = fonction(l)" si l n'est pas modifié dans la fonction me semble conforme à l'esprit du langage, autant faire "t = fonction(l)" où t est l modifié me semble non conforme.. Un simple "fonction(&l)" me semble nettement plus approprié..
[/EDIT]

Qu'en dis-tu Emmanuel ?

[Emmanuel Delahaye]

De plus, autant faire " l = fonction(l)" si l n'est pas modifié dans la fonction me semble conforme à l'esprit du langage, autant faire "t = fonction(l)" où t est l modifié me semble non conforme.. Un simple "fonction(&l)" me semble nettement plus approprié..

J'aime pas les doubles pointeurs, mais tu as raison sur le fond. Personnellement, j'utilise une structure por stocker le pointeur de début (et d'autres), donc, je passe l'adresse d'un structure. C'est beaucoup plus clair.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
struct list
{
    struct node *p_head;
    struct node *p_tail; /* eventuellement */
    /* int size; ... */
};
 
void list_add (struct list *this)
{
   ...