ç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
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 ...
Le Tout est souvent plus grand que la somme de ses parties.
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
git is great because Linus did it, mercurial is better because he didn't.
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'...)
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 ...»
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.
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.
Le Tout est souvent plus grand que la somme de ses parties.
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é
malloc foireux....
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
En recherche d'emploi.
Le Tout est souvent plus grand que la somme de ses parties.
git is great because Linus did it, mercurial is better because he didn't.
En recherche d'emploi.
Le Tout est souvent plus grand que la somme de ses parties.