IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Réseau C Discussion :

passage paramétres + copie tableaux


Sujet :

Réseau C

Vue hybride

Message précédent Message précédent   Message suivant Message suivant
  1. #1
    Membre du Club
    Profil pro
    Inscrit en
    Décembre 2002
    Messages
    10
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Décembre 2002
    Messages : 10
    Par défaut passage paramétres + copie tableaux
    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

  2. #2
    Expert confirmé
    Avatar de Skyounet
    Homme Profil pro
    Software Engineer
    Inscrit en
    Mars 2005
    Messages
    6 380
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 38
    Localisation : Etats-Unis

    Informations professionnelles :
    Activité : Software Engineer
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Mars 2005
    Messages : 6 380
    Par défaut
    A quel niveau le segfault ?

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

  3. #3
    Membre du Club
    Profil pro
    Inscrit en
    Décembre 2002
    Messages
    10
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Décembre 2002
    Messages : 10
    Par défaut passage paramétres + copie tableaux
    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

  4. #4
    Expert confirmé

    Profil pro
    Inscrit en
    Janvier 2007
    Messages
    10 610
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France

    Informations forums :
    Inscription : Janvier 2007
    Messages : 10 610
    Billets dans le blog
    2
    Par défaut
    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..

  5. #5
    Membre du Club
    Profil pro
    Inscrit en
    Décembre 2002
    Messages
    10
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Décembre 2002
    Messages : 10
    Par défaut
    Citation 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?

  6. #6
    Expert confirmé

    Profil pro
    Inscrit en
    Janvier 2007
    Messages
    10 610
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France

    Informations forums :
    Inscription : Janvier 2007
    Messages : 10 610
    Billets dans le blog
    2
    Par défaut
    montre ton nouveau code...

  7. #7
    Expert confirmé

    Profil pro
    Inscrit en
    Janvier 2007
    Messages
    10 610
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France

    Informations forums :
    Inscription : Janvier 2007
    Messages : 10 610
    Billets dans le blog
    2
    Par défaut
    Citation 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..

  8. #8
    Membre du Club
    Profil pro
    Inscrit en
    Décembre 2002
    Messages
    10
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Décembre 2002
    Messages : 10
    Par défaut
    personne ne voit?

  9. #9
    Expert confirmé

    Profil pro
    Inscrit en
    Janvier 2007
    Messages
    10 610
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France

    Informations forums :
    Inscription : Janvier 2007
    Messages : 10 610
    Billets dans le blog
    2
    Par défaut
    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);

  10. #10
    Expert éminent
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 68
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Par défaut
    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 : 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.

  11. #11
    Expert confirmé
    Avatar de diogene
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Juin 2005
    Messages
    5 761
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Enseignement

    Informations forums :
    Inscription : Juin 2005
    Messages : 5 761
    Par défaut
    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).

  12. #12
    Expert confirmé

    Profil pro
    Inscrit en
    Janvier 2007
    Messages
    10 610
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France

    Informations forums :
    Inscription : Janvier 2007
    Messages : 10 610
    Billets dans le blog
    2
    Par défaut
    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...

  13. #13
    Expert confirmé
    Avatar de diogene
    Homme Profil pro
    Enseignant Chercheur
    Inscrit en
    Juin 2005
    Messages
    5 761
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Enseignant Chercheur
    Secteur : Enseignement

    Informations forums :
    Inscription : Juin 2005
    Messages : 5 761
    Par défaut
    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é...
    ?

  14. #14
    Expert confirmé

    Profil pro
    Inscrit en
    Janvier 2007
    Messages
    10 610
    Détails du profil
    Informations personnelles :
    Âge : 67
    Localisation : France

    Informations forums :
    Inscription : Janvier 2007
    Messages : 10 610
    Billets dans le blog
    2
    Par défaut
    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é...

    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 ?

  15. #15
    Expert éminent
    Avatar de Emmanuel Delahaye
    Profil pro
    Retraité
    Inscrit en
    Décembre 2003
    Messages
    14 512
    Détails du profil
    Informations personnelles :
    Âge : 68
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : Décembre 2003
    Messages : 14 512
    Par défaut
    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 : 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)
    {
       ...

Discussions similaires

  1. [ Struts ] [ Jsp ] [ Javascript ] Passage paramètre
    Par bouchette63 dans le forum Struts 1
    Réponses: 7
    Dernier message: 23/05/2006, 14h04
  2. Exécution d'un prog avec passage paramètres
    Par licorne dans le forum C
    Réponses: 3
    Dernier message: 04/05/2006, 13h05
  3. [SQLSERVER]Pb passage paramètre procédure stockée
    Par galinijay dans le forum MS SQL Server
    Réponses: 2
    Dernier message: 01/08/2005, 11h59
  4. [JSP] Problème passage paramètre
    Par besco dans le forum Servlets/JSP
    Réponses: 5
    Dernier message: 13/09/2004, 10h15
  5. Fenêtre enfant MDI : passage paramètre à la création
    Par Orangina dans le forum C++Builder
    Réponses: 3
    Dernier message: 21/07/2004, 11h55

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo