passage paramétres + copie tableaux

**Genesis** · 13/05/2007, 15h15

Bonjour voila j'ai une liste chainée:

Code :

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

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

avec sa fonction ajouter:

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
 
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;
		memcpy(nouveau->pseudo, nom, strlen(nouveau->pseudo));
      /* 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;
}

à cette liste je veux y ajouter un tableau de caractéres construit 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;
ajoutListe(l, newfd, pseudo);

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

**Skyounet** · 13/05/2007, 15h46

A quel niveau le segfault ?

Je préférerais un str(n)cpy à la place du memcpy.

**Genesis** · 13/05/2007, 16h14

pourtant ma liste etait bien modifiée, moi et les pointeurs de tte maniére...

même avec ces modifications j'ai tjrs la même erreure...

apparemment c'est une erreure d'allocation mémoire mais je ne vois pas pourquoi

**souviron34** · 13/05/2007, 17h46

si tu n'as pas modifié ton code de départ, ta fonction ajouteliste retourne un pointeur sur une structure, et ton appel ne stocke dans rien.

De plus, comme déjà signalé, ton pointeur l n'est jamais modifié si tu as gardé ton code de départ..

**Genesis** · 13/05/2007, 18h02

Envoyé par souviron34

si tu n'as pas modifié ton code de départ, ta fonction ajouteliste retourne un pointeur sur une structure, et ton appel ne stocke dans rien.

De plus, comme déjà signalé, ton pointeur l n'est jamais modifié si tu as gardé ton code de départ..

si j'ai modifié mon code comme tu me l'as indiqué mais j'ai tjrs l'erreur.
en fait je pense qu'il y a un probléme à ce niveau la:

Code :

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

strcpy(nouveau->pseudo, nom );

NB:j'aimerais comprendre pourquoi alors avec ma fonction de depart ma liste etait bien modifiée?

**souviron34** · 13/05/2007, 18h04

montre ton nouveau code...

**souviron34** · 13/05/2007, 18h07

Envoyé par juve1897

as tu essayé ce que je t'avais proposé???

je sais que ça à l'air bête mais parfois ça résout le problème.

si ça te résout le problème c'est que tu as une erreur de mémoire ailleurs, c'est tout. Et que dans la nouvelle configuration tu n'écrases plus la même chose...

De la pure chance... sur laquelle il ne faut absolument pas compter..

**Genesis** · 14/05/2007, 17h38

personne ne voit?

**souviron34** · 13/05/2007, 15h51

Je vois déjà plusieurs problèmes :

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
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;
		memcpy(nouveau->pseudo, nom, strlen(nouveau->pseudo));    /* ne copie pas le '\0', donc nouvelle chaîne non terminée */
      /* chainage par defaut */
		nouveau->suivant = NULL;

      /* chainage */
		if (l == NULL){
         		/* c'est le premier : */
         		l = nouveau;    /* la déclaration de l n'en fait pas un pointeur modifiable */
		}
		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; /* ici l est inchangé */   
}

Donc je conseillerais :

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
 
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 );
 
      /* 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 SUCCESS ; 
        }
       else
            return ERROR ;
}

et :

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
 
#ifndef ERROR
#define ERROR 0
#endif
 
#ifndef SUCCESS
#define SUCCESS 1 
#endif
 
char pseudo[256];
int    statut ;
 
nbytes=recv(newfd,pseudo,sizeof(pseudo)-1,0);
pseudo[nbytes]='\0';
statut = ajoutListe(&l, newfd, pseudo);

**Emmanuel Delahaye** · 14/05/2007, 20h50

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 :

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.

**diogene** · 15/05/2007, 10h11

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** · 15/05/2007, 11h14

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** · 15/05/2007, 11h37

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** · 15/05/2007, 12h04

Envoyé par diogene

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** · 15/05/2007, 15h53

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 :

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

passage paramétres + copie tableaux

Réseau C

Vue hybride

Discussions similaires

Partager

Partager