Partage
  • Partager sur Facebook
  • Partager sur Twitter

pointeur sur structure de donnees

probleme de stockage

    17 juin 2021 à 23:52:13

    bonsoir a tous besoin d'aide.

    je debute en programmation en c et je ne maitrise pas beaucoup les pointeurs. On nous a demande a l'ecole de creer un traducteur a l'aide d'une table de hachage. Pour ca, j'ai declare une structure de donnees et un tableau de type structure de donnees. Mais  j'ai l'impression d'avoir mal passe mon tableau en parametre car ca bug a un niveau. Ou bien c'est au niveau de l'appel qu'il y'a erreur.

    Voici mon code:

    //ajouter un element dan le dictionnaire ainsi que sa traduction.
    void ajout(dic **tab){
    	int indice;
    	dic d;
        printf("\nEntrez le mot de la langue nationale:\t");
        scanf("%s",d.mot);
        printf("\nEntrez sa traduction en francais:\t");
        scanf("%s",d.trad);
        indice=hachage(d.mot);
        strcpy(tab[indice]->mot,d.mot);//on copie le mot saisi dans notre tableau(ca bug a ce niveau)
        strcpy(tab[indice]->trad,d.trad);//on copie egalement sa traduction dans notre tableau
    }


    int main()
    {
    ajout(tab);
    return 0;
    }
    Entrez le mot de la langue nationale:	mben
    
    Entrez sa traduction en francais:	bien
    Segmentation fault (core dumped)
    racky-237@racky237-HP-ProBook-450-G1:~/Bureau/code$ 
    



    • Partager sur Facebook
    • Partager sur Twitter
      18 juin 2021 à 0:18:26

      Salut,

      qu'est tab ? une table de structures ? As-tu alloué tab correctement ? Ou une table de pointeurs sur structures ? As-tu alloué tes structures correctement ?

      Ta fonction de hachage fonctionne-t-elle correctement ? Que vaut indice quand ça segfault ?

      Il nous manque du code. On veut voir ton allocation de tab et la définition de ta structure dico.

      • Partager sur Facebook
      • Partager sur Twitter

      Stringman devient Bonhomme !! | Jeux de plateforme : Nouvelle Démo. (màj : 24/04/2021)

        18 juin 2021 à 0:40:26

        drx a écrit:

        Salut,

        qu'est tab ? une table de structures ? As-tu alloué tab correctement ? Ou une table de pointeurs sur structures ? As-tu alloué tes structures correctement ?

        Ta fonction de hachage fonctionne-t-elle correctement ? Que vaut indice quand ça segfault ?

        Il nous manque du code. On veut voir ton allocation de tab et la définition de ta structure dico.


        struct dictio
        {
            char mot[taille_mot];
            char trad[taille_traducteur];
        };
        typedef struct dictio dic;
        
        dic *tab[nbre_mot];// on declare un tableau de type dic qui va contenir un autre tableau.
        

        voici ma structure et la declaration de tab

        • Partager sur Facebook
        • Partager sur Twitter
          18 juin 2021 à 3:04:48

          Tu as écrit:
          dic *tab[nbre_mot];// on declare un tableau de type dic qui va contenir un autre tableau
          C'est un tableau de pointeurs vers tes structures.
          Tu dois appeler malloc pour réserver l'espace pour chaque structure.
          Et on ne sait pas comment tu appelle ta fonction.
          • Partager sur Facebook
          • Partager sur Twitter

          Le Tout est souvent plus grand que la somme de ses parties.

            18 juin 2021 à 10:30:56

            drx a écrit:

            Salut,

            qu'est tab ? une table de structures ? As-tu alloué tab correctement ? Ou une table de pointeurs sur structures ? As-tu alloué tes structures correctement ?

            Ta fonction de hachage fonctionne-t-elle correctement ? Que vaut indice quand ça segfault ?

            Il nous manque du code. On veut voir ton allocation de tab et la définition de ta structure dico.

            je veux que tab soit un tableau de structure puis declarer un point vers tab.

            ma fonction hachage fonctionne bien et en faisant un printf voici ce qu'elle retourne: 

            racky-237@racky237-HP-ProBook-450-G1:~/Bureau/code$ ./d
            
            Entrez le mot de la langue nationale:	mben
            
            Entrez sa traduction en francais:	bien
            14
            Segmentation fault (core dumped)
            racky-237@racky237-HP-ProBook-450-G1:~/Bureau/code$ 
            


            voici mes bibliotheques et mes #define:

            #include<stdio.h>
            #include<stdlib.h>
            #include<string.h>
            
            
            #define taille_mot 10
            #define taille_traducteur 20
            #define nbre_mot 101
            

            Voici la fonction d'allocation de tab et son appel dans la fonction ajout:

            void allouer(dic **tab){
                tab=(dic**)malloc(sizeof(dic*)*nbre_mot);
                for (int i = 0; i < nbre_mot; i++)
                {
                   tab[i]=(dic*)malloc(sizeof(dic)*taille_mot);
                }
            }
            
            //ajouter un element dan le dictionnaire ainsi que sa traduction.
            void ajout(dic **tab){
                int indice;
                dic d;
                allouer(tab);
                printf("\nEntrez le mot de la langue nationale:\t");
                scanf("%s",d.mot);
                printf("\nEntrez sa traduction en francais:\t");
                scanf("%s",d.trad);
                printf("%s\n",d.trad);
                indice=hachage(d.mot);
                printf("%d\n",indice);
                strcpy(tab[indice]->mot,d.mot);//on copie le mot saisi dans notre tableau
                strcpy(tab[indice]->trad,d.trad);//on copie egalement sa traduction dans notre tableau
            }







            • Partager sur Facebook
            • Partager sur Twitter
              18 juin 2021 à 11:05:22

              Ça me semble un peu embrouillé tout cela ? Tu alloues ton tableau de mots (dic) à chaque fois que tu ajoutes un mot ? C'est pas très cohérent !

              Pour le segfault, Il ne faut pas oublier que les paramètre de fonction sont passé par copie. Donc le paramètre tab de la fonction allouer est une variable locale à la fonction allouer qui ne reçoit qu'une copie de l'argument tab que tu lui envois. La variable envoyé à la fonction reste elle inchangé. 

              Et puis, tu t'est un peu embrouiller en mélangeant tableaux sur la pile et sur le tas.

              -
              Edité par rouloude 18 juin 2021 à 11:30:05

              • Partager sur Facebook
              • Partager sur Twitter
                18 juin 2021 à 11:11:09

                Re,

                Si tab est amené à être un tableau de structures, tu dois déclarer : dic *tab.

                Déclarer dic *tab[NUM], c'est déclarer un tableau de NUM pointeurs sur dic.

                Ensuite, pour ne pas s'embrouiller dans les pointeurs sur pointeurs et tout ça, il ne faut pas que ta fonction d'allocation traite le pointeur de ton main (ou de la fonction supérieure) mais en créé un :

                /*** BOF ***/
                
                int main(void)
                {
                   dic *ptr;
                   allocDicList(&ptr);
                }
                
                void allocDicList(dic **ptr)//si tu n'es pas à l'aise, ce sera l'embrouille
                {
                   *ptr = malloc(NUM * sizeof(dic));
                   ....
                }
                
                /*** OUI ***/
                
                int main(void)
                {
                   dic *ptr = allocDicList();   
                }
                
                dic* allocDicList(void)
                {
                   dic* ptr = malloc(NUM * sizeof(dic));
                   ....
                   return ptr;
                }
                

                Ensuite, si tu as une table de structures, il n'est pas nécessaire d'allouer chaque index de la table, puisque qu'ils contiennent déjà le volume nécessaire.

                Au cas où tu aurais un doute, une table de structure sera plus efficace en traitement qu'une table de pointeurs sur structures, et moins bordélique en ram avec des données consécutives.

                -
                Edité par drx 18 juin 2021 à 11:14:51

                • Partager sur Facebook
                • Partager sur Twitter

                Stringman devient Bonhomme !! | Jeux de plateforme : Nouvelle Démo. (màj : 24/04/2021)

                  18 juin 2021 à 11:15:07

                  Bonjour,

                  là tu t'engouffres dans un puits de problèmes sans fond. Reprends au départ.

                  Je rappelle qu'une table de hachage (aka hashtable que j’abrégerai en HT), est une structure de donnée qui à une clé associe un enregistrement : c'est un tableau associatif. Ton enregistrement est une paire de mots (original, translated), la clé est le résultat de la fonction de hachage sur original. Il peut y avoir des collisions i.e. deux mots original qui auront la même clé. Souvent le moyen le plus simple pour la résolution de collision est qu'à chaque clé corresponde une liste de paires. Il faudra ensuite trouver dans cette liste le mot original pour avoir la traduction translated ou si tu ne le trouves pas signaler son absence.

                  Rien de ce que tu nous montres ne correspond à ça. Il va donc falloir revoir ta modélisation.

                  Par exemple, une paire pourrait-être modélisée par :

                  struct couple {
                      char *original;
                      char *translated;
                      // d'autres champs si tu trouves nécessaire d'en avoir plus
                  };
                  
                  struct couple couple_new(const char *original, const char*translated);
                  void couple_delete(struct couple *couple);
                  
                  const char* couple_original(struct couple* couple);
                  const char* couple_translated(struct couple* couple);
                  
                  ...

                  ensuite tu as besoin d'une liste de paires :

                  struct couple_list {
                      struct couple *couple;
                      struct couple_list *tail;
                  };
                  
                  struct couple_list *couple_list_new(void);
                  void couple_list_delete(struct couple_list *list);
                  
                  struct couple_list *couple_list_add(struct couple_list *list, struct couple *couple);
                  
                  bool couple_list_contains(struct couple_list *list, const char *string);
                  const struct couple *list_get_couple(struct couple_list *list, const char *string);

                  une fois que tu as tout ça tu peux commencer à construire la HT. Pour cela il te faut, la taille de la table, la table et la fonction de hachage :

                  struct hashtable {
                      size_t size;
                      size_t (*hashfunc)(const char *);
                      struct couple_list *table;
                  };
                  
                  struct hashtable *ht_new(size_t size, size_t (*hashfunc)(const char *));
                  void ht_delete(struct hashtable *ht);
                  
                  struct hashtable *ht_add(struct hashtable *ht, const char *original, const char *translated);
                  bool ht_contains(struct hashtable *ht, const char *original);
                  const char *ht_get_translation(struct hashtable *ht, const char *original);

                  Si tu remplis les trous au fur et à mesure tu auras quelque chose de bien plus clair et mieux structuré, enfin àmha.

                  Edit: juste pour dire que on est face à un problème XY. Et notre but n'est pas de t'aider à continuer de te planter. Je pense t'avoir donné l'API minimum dont tu as besoin. Elle est étoffable, et à prendre avec des pincettes parce que j'ai tout tapé à la volée.



                  -
                  Edité par White Crow 18 juin 2021 à 11:17:09

                  • Partager sur Facebook
                  • Partager sur Twitter
                    20 juin 2021 à 14:43:17

                    Merci pour votre aide, je vais de ce pas reprendre mon code.

                    Meme comme des zones restent un peu flou avec l'usage des pointeurs.

                    White Crow a écrit:

                    Bonjour,

                    là tu t'engouffres dans un puits de problèmes sans fond. Reprends au départ.

                    Je rappelle qu'une table de hachage (aka hashtable que j’abrégerai en HT), est une structure de donnée qui à une clé associe un enregistrement : c'est un tableau associatif. Ton enregistrement est une paire de mots (original, translated), la clé est le résultat de la fonction de hachage sur original. Il peut y avoir des collisions i.e. deux mots original qui auront la même clé. Souvent le moyen le plus simple pour la résolution de collision est qu'à chaque clé corresponde une liste de paires. Il faudra ensuite trouver dans cette liste le mot original pour avoir la traduction translated ou si tu ne le trouves pas signaler son absence.

                    Rien de ce que tu nous montres ne correspond à ça. Il va donc falloir revoir ta modélisation.

                    Par exemple, une paire pourrait-être modélisée par :

                    struct couple {
                        char *original;
                        char *translated;
                        // d'autres champs si tu trouves nécessaire d'en avoir plus
                    };
                    
                    struct couple couple_new(const char *original, const char*translated);
                    void couple_delete(struct couple *couple);
                    
                    const char* couple_original(struct couple* couple);
                    const char* couple_translated(struct couple* couple);
                    
                    ...

                    ensuite tu as besoin d'une liste de paires :

                    struct couple_list {
                        struct couple *couple;
                        struct couple_list *tail;
                    };
                    
                    struct couple_list *couple_list_new(void);
                    void couple_list_delete(struct couple_list *list);
                    
                    struct couple_list *couple_list_add(struct couple_list *list, struct couple *couple);
                    
                    bool couple_list_contains(struct couple_list *list, const char *string);
                    const struct couple *list_get_couple(struct couple_list *list, const char *string);

                    une fois que tu as tout ça tu peux commencer à construire la HT. Pour cela il te faut, la taille de la table, la table et la fonction de hachage :

                    struct hashtable {
                        size_t size;
                        size_t (*hashfunc)(const char *);
                        struct couple_list *table;
                    };
                    
                    struct hashtable *ht_new(size_t size, size_t (*hashfunc)(const char *));
                    void ht_delete(struct hashtable *ht);
                    
                    struct hashtable *ht_add(struct hashtable *ht, const char *original, const char *translated);
                    bool ht_contains(struct hashtable *ht, const char *original);
                    const char *ht_get_translation(struct hashtable *ht, const char *original);

                    Si tu remplis les trous au fur et à mesure tu auras quelque chose de bien plus clair et mieux structuré, enfin àmha.

                    Edit: juste pour dire que on est face à un problème XY. Et notre but n'est pas de t'aider à continuer de te planter. Je pense t'avoir donné l'API minimum dont tu as besoin. Elle est étoffable, et à prendre avec des pincettes parce que j'ai tout tapé à la volée.

                    Moi ausi je m'etais heurte au probleme de mot ayant la meme clef apres la fonction de hachage. Merci pour ton aide.



                    • Partager sur Facebook
                    • Partager sur Twitter
                      20 juin 2021 à 17:46:38

                      Ce n'est qu'une ébauche de code. Reprend au minimum la démarche : prends la notice du jeu, surligne les éléments qui font le jeu et tu auras tes structures de données. Ensuite surligne les éléments qui expliquent le déroulement du jeu et tu auras les fonctions de ton moteur de jeu. Seulement une fois que tu as quelque chose de clair qui permet de jouer tu pourras faire une interface de jeu.

                      • Partager sur Facebook
                      • Partager sur Twitter

                      pointeur sur structure de donnees

                      × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                      • Editeur
                      • Markdown