Discussion :

[Biosox]

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]

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]

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]

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]

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]

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]

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;
}