Programme au comportement étrange

**kromartien** · 28/01/2007, 20h33

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

la fonction affiche_tab :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Voici le tableau correspondant à la regle
00000000

**hiko-seijuro** · 28/01/2007, 22h34

ca c'est un ET bit à bit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

   if( m & numRegle )

**kromartien** · 28/01/2007, 23h06

Envoyé par hiko-seijuro

ca c'est un ET bit à bit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

   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.

**fearyourself** · 29/01/2007, 10h46

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

**kromartien** · 30/01/2007, 13h44

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[/paresseux]
(c'est la négation !a ?)

**fearyourself** · 30/01/2007, 15h35

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.

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 !

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

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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,

**Emmanuel Delahaye** · 31/01/2007, 00h16

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

Programme au comportement étrange

C

Vue hybride

Discussions similaires

Partager

Partager