[opérateur >>] pourquoi ça fait pas ce que je veux?

**Biosox** · 11/07/2006, 12h48

Bonjour. Je souhaite écrire une fonction int CreateMask(int borne) qui retourne un "masque de bit" en fonction de la borne:
exepmple:

CreateMask(4) retourne 0x0000000F
CreateMask(8) retourne 0x000000FF
CreateMask(6) retourne 0x0000003F
etc

Ma première idée, intuitive mais peu rapide, est de partir d'un "masque plein" et de le décaler autant de fois que necessaire:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
unsigned int CreateMask(unsigned int borne)
{
	int i;
	unsigned int ff = 0xFFFFFFFF;
 
	for(i=borne; i<32; i++)
	{
		ff = ff >> 1;
	}
	return ff;
}

et ça marche. Pout toutes les valeurs de borne de 0 à 32. (j'ajouterai plus tard un test sur l'argument)

Ensuite je me dit que ce serait équivalent et bien plus rapide de faire:

Code :

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

1
2
3
4
5
6
7
unsigned int CreateMask(unsigned int borne)
{
	unsigned int ff = 0xFFFFFFFF;
 
	ff = ff >> (32-borne);
	return ff;
}

mais je ne comprends pas pourquoi, ça ne marche pas pour borne = 0;
Au lieu d'obtenir 0x00000000 j'obtient 0xFFFFFFFF (alors qu'avec la premiere fonction avec la boucle for, ça marchait)

Alors bon, la solution est simple, je commence par tester la valeur de borne, et si elle vaut 0, je retourne 0.

Mais je veux comprendre pourquoi ça marche pas?
Merci d'éclairer ma lanterne!

Biosox

**joellel** · 11/07/2006, 13h10

Quand tu fais ff >> 32, 32 représente la taille de ton entier ff.
L'opérateur >> ne peut pas marcher avec un décalage >= à la taille de ton opérande de gauche.
Il faut donc bien que tu fasses la boucle!

**Médinoc** · 11/07/2006, 13h11

J'ignore si ça dépend ou non de ton compilo.

Tu devrais tester avec le contraire: décaler 0xFFFFFFFF vers la gauche, puis renvoyer le complément sur 32bits de cette valeur...

Code :

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

1
2
3
4
5
6
7
unsigned int CreateMask(unsigned int borne)
{
	unsigned int ff = (unsigned int)(-1);
 
	ff <<= borne; /* équivalent de ff = ff << borne */
	return ~ff;   /* complément de ff */
}

Et là, tester avec borne=32... (normalement, tu devrais obtenir 0xFFFFFFFF, si le bug se reproduit tu obtiendras 0x00000000)

**Franck.H** · 11/07/2006, 13h16

Envoyé par Médinoc

J'ignore si ça dépend ou non de ton compilo.

Tu devrais tester avec le contraire: décaler 0xFFFFFFFF vers la gauche, puis renvoyer le complément sur 32bits de cette valeur...

Code :

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

1
2
3
4
5
6
7
unsigned int CreateMask(unsigned int borne)
{
	unsigned int ff = (unsigned int)(-1);
 
	ff <<= borne; /* équivalent de ff = ff << borne */
	return ~ff;   /* complément de ff */
}

Et là, tester avec borne=32... (normalement, tu devrais obtenir 0xFFFFFFFF, si le bug se reproduit tu obtiendras 0x00000000)

Avec ta soluce sous GCC 4.0.3 sous Linux j'obtiens bien: 0x00000000 !

**Médinoc** · 11/07/2006, 13h30

Pareil, je me retrouve avec 0 aussi :

Code C :

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
#include <stdio.h>
 
unsigned int CreateMask(unsigned int borne)
{
unsigned int ff = (unsigned int)(-1);
 
ff <<= borne; /* \xe9quivalent de ff = ff << borne */
return ~ff;   /* compl\xe9ment de ff */
}
 
int main(void)
{
unsigned int i;
for(i=0 ; i<=32 ; i++) /* oui, <= */
	printf("Masque %2u : %08X\n", i, CreateMask(i));
return 0;
}

Code sortie :

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
Masque  0 : 00000000
Masque  1 : 00000001
Masque  2 : 00000003
Masque  3 : 00000007
Masque  4 : 0000000F
Masque  5 : 0000001F
Masque  6 : 0000003F
Masque  7 : 0000007F
Masque  8 : 000000FF
Masque  9 : 000001FF
Masque 10 : 000003FF
Masque 11 : 000007FF
Masque 12 : 00000FFF
Masque 13 : 00001FFF
Masque 14 : 00003FFF
Masque 15 : 00007FFF
Masque 16 : 0000FFFF
Masque 17 : 0001FFFF
Masque 18 : 0003FFFF
Masque 19 : 0007FFFF
Masque 20 : 000FFFFF
Masque 21 : 001FFFFF
Masque 22 : 003FFFFF
Masque 23 : 007FFFFF
Masque 24 : 00FFFFFF
Masque 25 : 01FFFFFF
Masque 26 : 03FFFFFF
Masque 27 : 07FFFFFF
Masque 28 : 0FFFFFFF
Masque 29 : 1FFFFFFF
Masque 30 : 3FFFFFFF
Masque 31 : 7FFFFFFF
Masque 32 : 00000000

On dirait que GCC n'apprécie pas le <<32... Mais j'ai la flemme de tester sous Visual.

**Biosox** · 11/07/2006, 13h36

sous visual: 0 aussi: j'ai utilisé ton code médinoc: sortie:

Masque 0 : 00000000
Masque 1 : 00000001
Masque 2 : 00000003
Masque 3 : 00000007

...

Masque 30 : 3FFFFFFF
Masque 31 : 7FFFFFFF
Masque 32 : 00000000

**Biosox** · 11/07/2006, 13h38

plutot que de boucler, j'ai finalement opté pour la méthode suivante:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
unsigned int CreateMask(unsigned int borne)
{
	unsigned int bm = 0xFFFFFFFF;
 
	if( 0 == borne )
	{
		bm = 0;
	}
	else
	{
		bm = bm >> (32-borne);
	}
	return bm;
}

**Emmanuel Delahaye** · 11/07/2006, 17h19

Envoyé par Biosox

plutot que de boucler, j'ai finalement opté pour la méthode suivante:
<...>

Pas portable. Manque un contrôle du paramètre... Je propose ceci (avec le test unitaire) :

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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
#include <stdlib.h>
#include <stdio.h>
 
/* Device Under Test */
static unsigned long CreateMask32 (unsigned int borne, int *perr)
{
   unsigned long bm = 0xFFFFFFFFu;
   int err = 0;
 
   if (borne <= 32)
   {
      if (0 == borne)
      {
         bm = 0;
      }
      else
      {
         bm = bm >> (32 - borne);
      }
   }
   else
   {
      err = 1;
 
   }
 
   if (perr != NULL)
   {
      *perr = err;
   }
   return bm;
}
 
static int tu (void)
{
#define N(a) (sizeof(a)/sizeof*(a))
   int ret = EXIT_SUCCESS;
 
   struct test
   {
      unsigned long nb;
      struct in
      {
         unsigned a;
      }
      in;
      struct out
      {
         unsigned long result;
         unsigned long err;
      }
      out;
   };
 
   static struct test a[] =
   {
      {10, 0, 0x00000000, 0},
      {12, 1, 0x00000001, 0},
      {13, 31, 0x7FFFFFFF, 0},
      {14, 32, 0xFFFFFFFFu, 0},
 
      {20, -1, 0xFFFFFFFFu, 1},
      {21, 33, 0xFFFFFFFFu, 1},
   };
 
   int err = 0;
   size_t i;
 
   for (i = 0; i < N (a) && !err; i++)
   {
      struct test const *p = a + i;
      int dut_err;
      unsigned long out = CreateMask32 (p->in.a, &dut_err);
      if (out != p->out.result)
      {
         printf ("ERROR on result at test %lu\n\n", p->nb);
         err = 1;
      }
      if (dut_err != p->out.err)
      {
         printf ("ERROR on err at test %lu\n\n", p->nb);
         err = 1;
      }
      if (dut_err)
      {
         puts ("D.U.T. error");
      }
   }
 
   if (!err)
   {
      puts ("\nP A S S E D\n");
   }
 
   return ret;
}
 
int main (void)
{
   int ret = tu ();
   return ret;
}

**Elijha** · 12/07/2006, 12h19

Salut,

J'ai bien une autre méthode, mais il reste à voir si cela est portable.

Code :

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

1
2
3
4
5
6
7
8
9
#include <limits.h>
.
.
unsigned int CreateMask(unsigned int borne)
{
  int nbBit = CHAR_BIT * sizeof(unsigned int) ;   // Nombre de bits
  unsigned long long ff = (unsigned int)-1 ;
  return (unsigned int)(ff>>(nbBit-(borne%(nbBit+1)))) ;
}

Dans une boucle avec la borne évoluant de 0 à 39

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
Masque  0 : 00000000h
Masque  1 : 00000001h
Masque  2 : 00000003h
Masque  3 : 00000007h
Masque  4 : 0000000Fh
Masque  5 : 0000001Fh
Masque  6 : 0000003Fh
Masque  7 : 0000007Fh
Masque  8 : 000000FFh
Masque  9 : 000001FFh
Masque 10 : 000003FFh
Masque 11 : 000007FFh
Masque 12 : 00000FFFh
Masque 13 : 00001FFFh
Masque 14 : 00003FFFh
Masque 15 : 00007FFFh
Masque 16 : 0000FFFFh
Masque 17 : 0001FFFFh
Masque 18 : 0003FFFFh
Masque 19 : 0007FFFFh
Masque 20 : 000FFFFFh
Masque 21 : 001FFFFFh
Masque 22 : 003FFFFFh
Masque 23 : 007FFFFFh
Masque 24 : 00FFFFFFh
Masque 25 : 01FFFFFFh
Masque 26 : 03FFFFFFh
Masque 27 : 07FFFFFFh
Masque 28 : 0FFFFFFFh
Masque 29 : 1FFFFFFFh
Masque 30 : 3FFFFFFFh
Masque 31 : 7FFFFFFFh
Masque 32 : FFFFFFFFh
Masque 33 : 00000000h
Masque 34 : 00000001h
Masque 35 : 00000003h
Masque 36 : 00000007h
Masque 37 : 0000000Fh
Masque 38 : 0000001Fh
Masque 39 : 0000003Fh

**Biosox** · 12/07/2006, 15h50

Envoyé par Emmanuel Delahaye

Pas portable. Manque un contrôle du paramètre... Je propose ceci (avec le test unitaire) :

Pour le controle du paramètre, c'est vrai, ça manquait.
Mais sinon, qu'est-ce qui fait que ma fonction n'est pas portable et que la tienne oui?

Je vois pas de différence à part le
0xFFFFFFFF
0xFFFFFFFFu

est-ce que le 'u' est necessaire? je pensais que du moment qu'on initialisait un entier avec une valuer héxa (0x...) il s'agissait d'une notation "unsigned" en quelque sorte?

Merci pour vos réponses et vos propostitions!

Biosox

**Emmanuel Delahaye** · 12/07/2006, 16h04

Envoyé par Biosox

Mais sinon, qu'est-ce qui fait que ma fonction n'est pas portable et que la tienne oui?

unsigned int 16 bits garantis
unsigned long : 32 bits garantis

Je vois pas de différence à part le
0xFFFFFFFF
0xFFFFFFFFu

est-ce que le 'u' est necessaire? je pensais que du moment qu'on initialisait un entier avec une valuer héxa (0x...) il s'agissait d'une notation "unsigned" en quelque sorte?

C'est possible, mais dans le doute, ça ne mange pas de pain... Il manque aussi le l (L):

0xFFFFFFFFul

ça, par contre, c'est indispensable, sinon sur une arcitecture 16-bit, on obtient un unsigned int, soit 0xFFFFu

**Biosox** · 13/07/2006, 10h08

[opérateur >>] pourquoi ça fait pas ce que je veux?

C

Discussions similaires

Partager

Partager