Partage
  • Partager sur Facebook
  • Partager sur Twitter

malloc foireux....

    12 janvier 2022 à 21:58:04

    Bonjour à tous,

    Je doit créer un plateau et pour cela j'ai besoin de mapper chaque case. Je ne connais pas la taille avant la compilation donc obliger malloc.

    Je fais donc tout le train train pour récupérer [x][y] et c'est stocker dans une structure plateau que voici

    typedef struct plateau {
        unsigned hauteur;
        unsigned largeur;
        unsigned nombre_snake;
        unsigned niveau;
        case_plateau ** position_case;
    
    }plateau;

    Donc je mets à jour ma structure au fur et à mesure de l'exécution, et j'arrive dans ma fonction qui gére le malloc

    case_plateau** mappage_plateau(plateau p)
    {
        case_plateau** map= NULL;
        map=(case_plateau**)malloc(p.hauteur*sizeof(case_plateau*));
        for(int i =0; i<p.largeur; i++)
        {
            map[i]=(case_plateau*)malloc(p.largeur*sizeof(case_plateau));
        }
        for(int i =0; i<p.hauteur; i++)
        {
            for(int j =0; j<p.largeur; j++)
            {
                map[i][j].obstacle=false;
                map[i][j].vide=true;
            }
        }
        return map;
    }

    ça marche nickel quand la largeur ==  la hauteur. La ou ça foire c'est quand l'une des deux est différente.

    Et quand je change le sens en inversant i et j etc... ça fonctionne mais ça ne marche plus dans l'autre sens. 

    ex

    largeur = 8 ,hauteur =8   ok
    
    largeur = 8 ,hauteur =7   ok
    
    largeur = 7 ,hauteur =8   pas ok donc inversion
    
    largeur = 8 ,hauteur =8   ok
    
    largeur = 7 ,hauteur =8   ok
    
    largeur = 8 ,hauteur =8   pas ok

    Je m'arrache les cheveux depuis quelques heures, je viens donc faire un appel à l'aide :p

    Si vous avez une idée :)

    Bonne année à tous

    • Partager sur Facebook
    • Partager sur Twitter
      12 janvier 2022 à 22:08:43

      Bonjour,

      Ligne 4, tu crées un tableau de p.hauteur pointeurs.
      Ligne 5, tu le parcours en itérant p.largeur fois pour le remplir!

      • Partager sur Facebook
      • Partager sur Twitter

      En recherche d'emploi.

        12 janvier 2022 à 23:03:07

        Bonsoir,

        connais-tu les outils genre valgrind qui te permettraient de debuguer facilement ce genre de problème ?

        • Partager sur Facebook
        • Partager sur Twitter
          13 janvier 2022 à 2:17:18

          Dalfab t'a montré la solution à ton problème.
          Si tu ne comprends pas ce que tu fais, ça ne sert à rien de jouer aux devinettes.
          «je vais essayer ceci au cas où ça marcherais ...»
          Tu risques de perdre beaucoup de temps avec ce genre de stratégie ...
          • Partager sur Facebook
          • Partager sur Twitter

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

            13 janvier 2022 à 8:51:33

            En général on préfère un tableau linéarisé, cela évite de fragmenter autant la mémoire et d'avoir une région contigue. Cela évite aussi de devoir tester que tous les malloc fonctionnent et/ou devoir les supprimer en cas de problème.

            #include <stdio.h>
            #include <stdlib.h>
            
            #if 0
            
                      0      1      2      3        (w = 4)
            
                  +------+------+------+------+
            0     | 0    | 1    | 2    | 3    |
            1     | 4    | 5    | 6    | 7    |
            2     | 8    | 9    | (10) | 11   |
                  +------+------+------+------+
            
            (h = 3)
            
            #endif
            
            #define W 4
            #define H 3
            
            int
            main(void)
            {
            	int *tab;
            
            	if (!(tab = calloc(W * H, sizeof (*tab)))) {
            		perror("calloc");
            		exit(1);
            	}
            
            	for (size_t i = 0; i < W * H; ++i)
            		tab[i] = i;
            
                // accès case 9 (colonne 2, ligne 2)
            	printf("accès case 9 (c=2, r=2): %d\n", tab[2 + 2 * W]);
            }



            -
            Edité par markand 13 janvier 2022 à 9:00:06

            • Partager sur Facebook
            • Partager sur Twitter

            l'azerty est aux dispositions ce que subversion est aux SCM

              13 janvier 2022 à 10:51:14

              Quand on n'est pas très à l'aise avec les 'malloc' (je parle de moi...), une autre solution est d'utiliser des tableaux de taille fixe, cette taille fixe étant dans un #define. Ici il s'agit d'un plateau de jeu, donc les tableaux ne feront probablement jamais plus de 100x100 (si ?), le gaspillage de mémoire vive est donc minuscule. (Les infos 'hauteur' et 'largeur' restent indispensables pour ne pas dépasser les limites du tableau utile, plus petit que le tableau déclaré en mémoire).

              Avantage : ça peut faire gagner du temps de programmation (par contre, d'un point de vue pédagogique, c'est pas comme ça qu'on deviendra à l'aise avec les 'malloc'...)

              • Partager sur Facebook
              • Partager sur Twitter
                13 janvier 2022 à 11:46:30

                PierrotLeFou a écrit:

                Dalfab t'a montré la solution à ton problème.
                Si tu ne comprends pas ce que tu fais, ça ne sert à rien de jouer aux devinettes.
                «je vais essayer ceci au cas où ça marcherais ...»

                Y aurait-il un message que l'on ne voit pas ?

                • Partager sur Facebook
                • Partager sur Twitter
                  13 janvier 2022 à 13:28:03

                  Zero.c a écrit:

                  PierrotLeFou a écrit:

                  Dalfab t'a montré la solution à ton problème.
                  Si tu ne comprends pas ce que tu fais, ça ne sert à rien de jouer aux devinettes.
                  «je vais essayer ceci au cas où ça marcherais ...»

                  Y aurait-il un message que l'on ne voit pas ?

                  En effet, j'ai juste l'impression que @Don_raftapss a fait une petite faute d'inattention dans son code par ailleurs très correct.
                  • Partager sur Facebook
                  • Partager sur Twitter

                  En recherche d'emploi.

                    13 janvier 2022 à 16:06:37

                    N'aurait-il pas été plus simple d'envoyer l'adresse d'un plateau à la fonction ?

                    Car comme est conçu la fonction, il va falloir ensuite affecter le pointeur retourné, au champ case_plateau du plateau passé en argument.

                    voire même une fonction qui retourne un plateau (ou l'adresse d'un plateau) créé avec les dimensions (hauteur, largeur) passées en paramètre.

                    -
                    Edité par rouIoude 13 janvier 2022 à 17:20:17

                    • Partager sur Facebook
                    • Partager sur Twitter
                      13 janvier 2022 à 17:31:34

                      Je faisais allusion à la phrase:
                      «Et quand je change le sens en inversant i et j etc... ça fonctionne mais ça ne marche plus dans l'autre sens.»
                      Pourquoi changer de sens? Il faut comprendre.
                      On le fait tous parfois, mais fonctionner par essais et erreurs, ce n'est pas très génial.
                      • Partager sur Facebook
                      • Partager sur Twitter

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

                        17 janvier 2022 à 12:53:45

                        PierrotLeFou a écrit:

                        Je faisais allusion à la phrase:
                        «Et quand je change le sens en inversant i et j etc... ça fonctionne mais ça ne marche plus dans l'autre sens.»
                        Pourquoi changer de sens? Il faut comprendre.
                        On le fait tous parfois, mais fonctionner par essais et erreurs, ce n'est pas très génial.

                        Merci de vos réponse,

                        Je sais utilisé malloc calloc et realloc. J'ai fais une faute d’inattention en faite :D. Et j'ai pas regarder le for qui est certainement un copier coller dde l'autre ou j'ai changer I -> J. Donc en effet c'est l'erreur :D

                        White Crow a écrit:

                        Bonsoir,

                        connais-tu les outils genre valgrind qui te permettraient de debuguer facilement ce genre de problème ?


                        Du tout je vais aller voir

                        markand a écrit:

                        En général on préfère un tableau linéarisé, cela évite de fragmenter autant la mémoire et d'avoir une région contigue. Cela évite aussi de devoir tester que tous les malloc fonctionnent et/ou devoir les supprimer en cas de problème.

                        #include <stdio.h>
                        #include <stdlib.h>
                        
                        #if 0
                        
                                  0      1      2      3        (w = 4)
                        
                              +------+------+------+------+
                        0     | 0    | 1    | 2    | 3    |
                        1     | 4    | 5    | 6    | 7    |
                        2     | 8    | 9    | (10) | 11   |
                              +------+------+------+------+
                        
                        (h = 3)
                        
                        #endif
                        
                        #define W 4
                        #define H 3
                        
                        int
                        main(void)
                        {
                        	int *tab;
                        
                        	if (!(tab = calloc(W * H, sizeof (*tab)))) {
                        		perror("calloc");
                        		exit(1);
                        	}
                        
                        	for (size_t i = 0; i < W * H; ++i)
                        		tab[i] = i;
                        
                            // accès case 9 (colonne 2, ligne 2)
                        	printf("accès case 9 (c=2, r=2): %d\n", tab[2 + 2 * W]);
                        }

                        Je pense jamais a dessiner mes trucs en commentaire c'est noté :)





                        • Partager sur Facebook
                        • Partager sur Twitter

                        malloc foireux....

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