Programme au comportement étrange

Version imprimable

Bonjour, j'écris un programme sur le jeu de la vie en deux dimensions, mais j'ai un problème. Le code fonctionnait bien, et maintenant, il ne marche pus, c'est à dire que dans mon scripte je fais une transcription entier - > tableau de bits et j'obtiens toujours 00000000 alors qu'avant j'obtenais la bonne représentation. je vous donne les appels et le corps de la fonction :
Code:

1 2 3 printf("Voici le tableau correspondant à la regle\n"); affiche_tab(tableau_regle(nregle),8);
la fonction affiche_tab :
Code:

1 2 3 4 5 6 7 8 9 10 11 void affiche_tab(short * tab, short nbr_elem) { short i=0; while(i<nbr_elem) { printf("%d",tab[i]); i++; } printf("\n"); }
la fonction tableau_regle :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 short * tableau_regle(short numRegle) { short i=0; short m=1; short * regle = NULL; regle = malloc( 8 * sizeof(short)); m = m << 7; while(i<8) { if( m & numRegle ) { regle[i]=1; } else { regle[i]=0; } m = m >> 1; i++; } return regle; }
Le retour :
Code:

1 2 Voici le tableau correspondant à la regle 00000000

28/01/2007, 22h34
hiko-seijuro

ca c'est un ET bit à bit :

Code:

if( m & numRegle )
28/01/2007, 23h06
kromartien

Citation:

Envoyé par hiko-seijuro

ca c'est un ET bit à bit :

Code:

if( m & numRegle )

Oui tout à fait. Une comparaison de 10000000 (==1<<7)
avec un entier qui vaut 128 , soit en binaire 10000000 renvoie 10000000, c'est à dire une valeur qui en logique équivaut à 1. Ainsi si le bit étudié vaut 1, la comparaison sort un vrai (valeur != 0) et assigne 1 au tableau de sortie.
29/01/2007, 10h46
fearyourself

Je ne vois pas de problème (à part le manque de test après un malloc) et que le code me semble plus compliqué que ce qu'on pourrait faire...

La seule erreur que je vois est la mauvaise utilisation du paramètre nregle.

Un code complet et compilable permettrait de mieux comprendre ce que tu fais de mal.

Jc

Code:

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 #include <stdlib.h> #include <stdio.h> short * tableau_regle(short numRegle) { short i=0; short m=1; short * regle = NULL; regle = malloc( 8 * sizeof(short)); m = m << 7; while(i<8) { if( m & numRegle ) { regle[i]=1; } else { regle[i]=0; } m = m >> 1; i++; } return regle; } void affiche_tab(short * tab, short nbr_elem) { short i=0; while(i<nbr_elem) { printf("%d",tab[i]); i++; } printf("\n"); } int main(void) { short nregle=0; while(nregle<1||nregle>255) { printf("entrez le numero de regle sur 8 bits (1 ... 255)"); scanf("%d",&nregle); } printf("Voici le tableau correspondant à la regle %d\n",nregle); affiche_tab(tableau_regle(nregle),8); return 0; }
Voilà une source complète, mais comme on peut s'y attendre, elle marche impec. (Pour l'optimisation, je veux bien en savoir + :) nregle mal utilisée ? Je ne vois pas ) .
Le problème c'est dans le programme complet, ça bloque. Enfin c'est rassurant de voir que le bout isolé marche.
Pour le test de malloc, est ce que j'ai le droit de faire

au lieu de
Code:

1 2 3 4 regle=malloc(sizeof(short)*8); if(regle) else printf("Probleme d'allocation de mémoire");
?
Après avoir bien sûr déclaré un pointeur sur char pour regle.
[paresseux]
Si c'était possible, ça m'éviterait de ne pas tester les mallocs, parce que sinon c'est pénible à écrire. Ou même encore pire :
Code:

1 2 3 if(!char * regle=malloc(sizeof(short)*8)) printf("Problème d'allocation mémoire");
[/paresseux]
(c'est la négation !a ?)

Citation:

Envoyé par kromartien

Le problème c'est dans le programme complet, ça bloque. Enfin c'est rassurant de voir que le bout isolé marche.

Alors il faut trouver avec l'aide d'un debuggeur le cas qui pose problème. Sans cela, ce sera difficile de se prononcer.

Citation:

Pour le test de malloc, est ce que j'ai le droit de faire

Code:

1
2
3
4
regle=malloc(sizeof(short)*8);
if(regle)
else
printf("Probleme d'allocation de mémoire");

Tu n'as pas le droit mais le devoir ! :wink:

Il faut tester le retour de malloc (voir mon code à la fin)

Citation:

[paresseux]
Si c'était possible, ça m'éviterait de ne pas tester les mallocs, parce que sinon c'est pénible à écrire. Ou même encore pire :

Code:

1
2
3
 
if(!char * regle=malloc(sizeof(short)*8))
printf("Problème d'allocation mémoire");

[/paresseux]

Là par contre, tu ne peux pas le faire. La programmation n'est pas un boulot de paresseux à cet extrême, il vaut mieux avoir un code aéré et compréhensible qu'un code avec le moins de lignes possible :wink:

Voici le code que j'ai fait en corrigeant et réduisant ton calcul, pose des questions si quelque chose te semble bizarre :

Code:

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
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
 
 
int * tableau_regle(int numRegle)
{
   int m=7;
   int * regle = NULL;
   regle = malloc( 8 * sizeof(*regle));
 
   /* Test sur le retour de malloc */
   if(regle == NULL) {
     return NULL;
   }
 
   /* Plus direct */
   while(m>=0) {
    regle[m] = numRegle&1;
    numRegle >>= 1;
    m--;
   }
 
   return regle;
}
 
 
void affiche_tab(int * tab, int nbr_elem)
{
   int i=0;
   while(i<nbr_elem)
{
      printf("%d",tab[i]);
      i++;
}
   printf("\n");
}
 
int main(void)
{
   char *end;
   int nregle=0;
   char buf[32];
   int *res;
 
   /* Ce code est plus long, car beaucoup de tests mais plus sûr */
   while(nregle<1||nregle>255)
   {
      printf("entrez le numero de regle sur 8 bits (1 ... 255)");
 
      /* On recupere la ligne */
      if(fgets(buf, sizeof(buf), stdin) == NULL) {
          fprintf(stderr,"Erreur avec fgets\n");
          return EXIT_FAILURE;
      }
 
      /* Si on a au moins un '\n' alors on peut continuer sinon il faudrait demander a l'utilisateur de recommencer, je me facilite la vie en sortant */
      if(strchr(buf, '\n')==NULL) {
          fprintf(stderr,"Erreur avec strchr\n");
          return EXIT_FAILURE;
      }
 
      /* On transforme l'entree en nombre */
      nregle = strtol(buf, &end, 0);
 
      /* Si on a eu un probleme, il faudrait demander a l'utilisateur de recommencer, je me facilite la vie en sortant */
      if((end==buf)||(*end != '\n')) {
          fprintf(stderr,"Erreur avec strtol\n");
          return EXIT_FAILURE;
      }
   }
 
   res = tableau_regle(nregle);
 
   if(res==NULL) {
      fprintf(stderr,"Erreur avec tableau_regle\n");
      return EXIT_FAILURE;
   }
 
   printf("Voici le tableau correspondant à la regle %d\n",nregle);
   affiche_tab(res,8);
 
   free(res);
   return EXIT_SUCCESS;
}

Jc

EDIT : Ajout d'un joli free, :merci:

30/01/2007, 16h01
crocodilex

N'oubliez pas de libérer la mémoire que vous allouez ;)
30/01/2007, 16h08
David.Schris
Bonjour,

Citation:

Envoyé par fearyourself

[...]
Tu n'as pas le droit mais le devoir ! :wink:

Il faut tester le retour de malloc (voir mon code à la fin)

Je "plussoie".

Citation:

Envoyé par fearyourself

[...] Là par contre, tu ne peux pas le faire. La programmation n'est pas un boulot de paresseux à cet extrême, il vaut mieux avoir un code aéré et compréhensible qu'un code avec le moins de lignes possible :wink: [...]

AMHA, un code de paresseux n'est pas un code avec le moins de lignes possibles (ça, c'est du code d'inconscient) : le paresseux, avec l'expérience, sait qu'il gagne plus de temps à écrire du code lisible/maintenable qu'à économiser ses frappes au clavier.
Citation:
Envoyé par fearyourself

Voici le code que j'ai fait en corrigeant et réduisant ton calcul, pose des questions si quelque chose te semble bizarre :

Code:

1 2 3 4 /* [...] */ affiche_tab(tableau_regle(nregle),8); /* [...] */ }
Que se passe-t-il si tableau_regle() renvoie NULL ?

Cordialement,
DS.
30/01/2007, 17h23
fearyourself

Citation:

Envoyé par crocodilex

N'oubliez pas de libérer la mémoire que vous allouez

et

Citation:

Envoyé par David.Schris

Que se passe-t-il si tableau_regle() renvoie NULL ?

Exact, j'ai oublié de changer cette fin de code. C'est rectifié.

:merci:

Citation:

Envoyé par kromartien

Bonjour, j'écris un programme sur le jeu de la vie en deux dimensions, mais j'ai un problème. Le code fonctionnait bien, et maintenant, il ne marche pus, c'est à dire que dans mon scripte je fais une transcription entier - > tableau de bits et j'obtiens toujours 00000000 alors qu'avant j'obtenais la bonne représentation. je vous donne les appels et le corps de la fonction :

Ton code fonctionne,
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 Voici le tableau correspondant a la regle 00000000 00000001 00000010 00000011 00000100 00000101 00000110 00000111 00001000 00001001 00001010 00001011 00001100 00001101 00001110 00001111 00010000 00010001 00010010 00010011 Press ENTER to continue.
mais il est inutilement complexe et, comme souvent, néglige les choses importantes... Il est aussi trop rigide. Ce 8, c'est horrible...
Code:

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 #include <stdio.h> #include <stdlib.h> int *tableau_regle (unsigned numRegle, size_t const n) { unsigned *regle = malloc (n * sizeof *regle); if (regle != NULL) { size_t i; unsigned m = 1 << (n - 1); for (i = 0; i < n; i++) { regle[i] = (m & numRegle) ? 1 : 0; m >>= 1; } } return regle; } void affiche_tab (unsigned *tab, size_t nbr_elem) { size_t i; for (i = 0; i < nbr_elem; i++) { printf ("%u", tab[i]); } printf ("\n"); } int main (void) { size_t n = 4; int nregle; printf ("Voici le tableau correspondant a la regle\n"); for (nregle = 0; nregle < 1 << n; nregle++) { unsigned *tab = tableau_regle (nregle, n); if (tab != NULL) { affiche_tab (tab, n); free (tab), tab = NULL; } } return 0; }
Pose des questions si tu ne comprends pas.