passage paramétres + copie tableaux

Version imprimable

Voir 40 message(s) de cette discussion en une page

14/05/2007, 19h12
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:

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:

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

et ma fonction ajoutListe:

Code:

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

et...je ne vois pas pourquoi nom ne pointerait pas vers mon tableau de caracteres...
14/05/2007, 20h39
Skyounet

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

Citation:

Envoyé par Genesis

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:

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:

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:

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

Citation:

Envoyé par Genesis

Code:

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

Code:

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.

Citation:

Envoyé par Genesis

Code:

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:

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

14/05/2007, 21h14
Emmanuel Delahaye

Citation:

Envoyé par Genesis

comme ca c'est bon:

Code:

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:

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

Souviron34 :

Code:

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

15/05/2007, 11h14
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...
15/05/2007, 11h37
diogene

souviron34

Citation:

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

Citation:

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

bien sur

Citation:

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

?

Citation:

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

Citation:

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

Personnellement, je préfère aussi cette solution

Citation:

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é...

?
15/05/2007, 12h04
souviron34

Citation:

Envoyé par diogene

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

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

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... :mouarf:

[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 ?
15/05/2007, 15h53
Emmanuel Delahaye
Citation:

Envoyé par souviron34

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:

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

Voir 40 message(s) de cette discussion en une page