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

Si vous avez une idée

Bonne année à tous

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!

Bonsoir,

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

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

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

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

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 ?

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.

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

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.

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

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é