.NET Framework - Opération_bitwise

Asked By Gloops

12-Nov-09 08:49 AM

Bonjour tout le monde,

Lorsque je lis la description de l'op=E9rateur bitwise AND (&) =E0 l'adre=
sse=20
http://msdn.microsoft.com/fr-fr/library/z0zec0b2.aspx
et que je cherche =E0 la mettre en =9Cuvre, j'en viens =E0 me demander si=
elle=20
est valable sous C#.

En effet, si je tape le code suivant :

ushort usKS =3D (ushort) 0x91;
ushort usScroll =3D (ushort) 0x91;
usKS =3D usKS & usScroll;

histoire de ne retenir que le bit utile dans la premi=E8re variable si=20
elle contenait aussi autre chose (=E0 supposer qu'on l'ait initialis=E9e =

diff=E9remment, mais chaque chose en son temps),

on me jette =E0 la troisi=E8me ligne en me disant
Error	1	Cannot implicitly convert type 'int' to 'ushort'. An explicit=20
conversion exists (are you missing a cast?)=09
(CS0266)

Alors c'est quoi, le "cast" que je "miss" ?
J'ai pourtant bien l'impression d'avoir tout d=E9clar=E9 en ushort (enfin=
du=20
moins les variables que je mentionne ici), o=F9 est-ce qu'on me trouve un=
=20
int ?

J'aurais laiss=E9 tomber un vilebrequin sur la route ?

Au d=E9part c'=E9tait un UInt16 que j'avais =E0 filtrer, et puis comme l'=
aide=20
de l'op=E9rateur "&" utilisait des ushort dans son exemple j'ai fait=20
l'op=E9ration avec des ushort histoire d'essayer d'y voir clair. Vi, ben =

=E7a sera pour le prochain =E9pisode.

Je pr=E9cise que j'ai utilis=E9 la commande Build / Rebuild solution, et =
que=20
j'ai obtenu la m=EAme erreur sur la m=EAme ligne.

12-Nov-09 09:13 AM

Gloops a =E9crit, le 12/11/2009 14:49 :
resse=20


J'ai bien fait d'afficher =E7a dans Firefox : la premi=E8re ligne appara=EE=
t=20
beaucoup plus en valeur, et du coup je r=E9alise que je ne travaillais pa=
s=20
avec la bonne aide.

Si je ne m'abuse on sera moins hors sujet l=E0 :
http://msdn.microsoft.com/fr-fr/library/sbf85k1c(VS.80).aspx

d'autant plus que je travaille effectivement sous Visual Studio 2005=20
avec .Net 2.

S'agissant d'un & binaire, je vois une ligne d'exemple qui m'int=E9resse =

bien :
Console.WriteLine("0x{0:x}", 0xf8 & 0x3f);  // bitwise and

et l=E0-dedans je vois la partie op=E9ration, 0xf8 & 0x3f

Ben =E7a ressemble bien =E0 ce que j'avais fait.
Ah oui c'=E9tait avec les types de variables, qu'on mthemb=EAtait.
Ai-je bien lu sur la page mentionn=E9e que le & binaire est d=E9fini sur =
les=20
types int=E9gr=E9s, et si je me r=E9f=E8re l=E0, ushort devrait bien en f=
aire partie :
http://msdn.microsoft.com/fr-fr/library/bfft1t3c%28VS.80%29.aspx

C'est o=F9, que je me suis gour=E9 ?

12-Nov-09 10:58 AM

=E7a demeure un dr=F4le de binse, dont je me suis sorti dans le cas pr=E9=
sent=20
par une conversion en binaire, par Convert.ToString(nombre, 2)

Comme il s'agit de d=E9terminer si le dernier bit est =E0 1 ou 0, finalem=
ent=20
=E7a devient assez simple.

Si quelqu'un avait une r=E9ponse un peu plus acad=E9mique =E0 ma question=
je=20
reste preneur ...
_____________________________________
Gloops a =E9crit, le 12/11/2009 14:49 :
resse=20
si elle=20

e=20
in du=20
un=20
l'aide=20
n=20
t que=20

17-Nov-09 06:00 AM

Bonjour,

Quelque chose comme ?

ushort v1 = 0xf0;
ushort v2 = 0xff;
const ushort mask=1;
Console.WriteLine(v1 & mask); // 0 le dernier bit étant 0
Console.WriteLine(v2 & mask); // 1 le dernier bit étant 1
Console.ReadKey();

Généralement on garde l'intégralité de la valeur et on teste avec un

Apparemment  le 1 combinant deux ushort retourne effectivement un int. Il
faudrait donc alors utiliser :

r = (ushort)(v1 & mask);

si on veut garder le résultat du "masquage".

--
Patrice

17-Nov-09 08:01 AM

Patrice a =E9crit, le 17/11/2009 12:00 :


ec un=20
Il=20

Merci pour cette r=E9ponse.

Effectivement, voil=E0 qui fonctionne.

J'avais essay=E9 un truc du style
uKS =3D (ushort) (((ushort) uKS) & ((ushort) uScroll))

mais m=EAme avec =E7a je n'=E9tais pas copain avec le compilateur.
Ce que je verrais bien =E0 redire c'est que c'est lourd, mais au moins je=
=20
dis quel type de valeur je m'attends =E0 r=E9cup=E9rer, mais lui voit du =
int=20
l=E0-dedans. Ah oui c'est le retour du &, tu dis ? Oui =E7a c'est bon =E0=
=20
savoir. Bon, je vais r=E9essayer la syntaxe que je viens de citer, =E7a=20
remonte quand m=EAme =E0 quelques jours.

17-Nov-09 08:22 AM

Patrice a =E9crit, le 17/11/2009 12:00 :


ec un=20
Il=20

=E7a y est, je viens de r=E9essayer, et je ne me suis pas fait jeter.
Apparemment, le fait de savoir que le r=E9sultat d'un masquage entre=20
ushort donne un int a =E9t=E9 d=E9cisif.

C'est bizarre, conceptuellement, d'ailleurs, non ?
On fait un masquage entre donn=E9es cod=E9es sur 16 bits chacune, et on s=
e=20
retrouve avec une donn=E9e sur 32 bits. Soit j'ai mal compris, soit les 1=
6=20
bits sup=E9rieurs du r=E9sultat n'ont aucune chance de contenir autre cho=
se=20
que z=E9ro. Serait-ce encore "by design" ?

Au fait c'est document=E9 o=F9 ?

18-Nov-09 01:22 PM

Donc un seul cast doit suffire (ou stocker le résultat sous forme d'un int).
Effectivement je suis assez d'accord et je n'ai pas trouvé le fin mot de
l'histoire (j'ai juste vu que la valeur produite était un int).

Je dirais que les valeurs produites doivent être nécessairement sur 32 bit
ou 64 bit (mon "assembleur" est un peu loin mais je pense que les opérandes
sont étendus à des valeurs 32 ou 64 bits et que le résultat produit est donc
en 32 ou 64 bits sans doute parce que le processeur ne peut pas exécuter une
instruction AND sur 16 bits sur une architecture 32 bits ?).

--
Patrice

19-Nov-09 10:02 AM

Patrice a =E9crit, le 18/11/2009 19:22 :
n int).=20

Oui, je sais, j'ai fait fort :)
D'ailleurs, puisque je n'ai pas eu le r=E9sultat, je pense qu'au d=E9but =

j'ai d=FB mettre seulement ceux qui n'=E9taient pas n=E9cessaires. Une fo=
is=20
qu'on sait, il faut reconna=EEtre que c'est plus facile.

de=20

Ah oui avec une fonction du type typeof ...
(ou plut=F4t typename, si je me rappelle bien, typeof c'est pour vb ?)
Il faut avoir l'id=E9e, de passer toutes les variables dans cette=20
moulinette, y compris les r=E9sultats de calculs.
Bon, =E0 la r=E9flexion, c'est vrai que si on me reproche de mettre ensem=
ble=20
des donn=E9es de type diff=E9rent ...

32 bit=20
randes=20
it est donc=20
ter une=20


Ah, mon assembleur doit =EAtre encore plus loin : je n'y avais pas pens=E9=


Bon, eh bien maintenant, je t=E2cherai de me le tenir pour dit.
Merci pour le tuyau.

19-Nov-09 12:56 PM

Le probl?me vient plus, amha, de l'adressage m?moire que de la capacit? du
microprocesseur ? faire des op?ration logiques sur 16 bits (ils doivent
pouvoir le faire pour rester compatibles x86, je dirais).

20-Nov-09 06:30 AM

Christophe Lephay a =E9crit, le 19/11/2009 18:56 :
cit=E9=20


Oh, j'imagine que le processeur veut bien faire tout ce qu'on lui dira,=20
du moment qu'on sait lui dire :)

http://download.intel.com/design/processor/manuals/253666.pdf
page 108

Ah oui, c'est vrai qu'il faut prendre en compte plusieurs modes. J'en ai =

d=E9j=E0 entendu qui se moquent quand on en =E9tudie un ...
Patrice parlait de l'environnement 32 bits. C'est la colonne Comp/Leg=20
qu'il faut regarder ? J'avoue que l=E0, j'ai un flou.
Ah, en supposant que =E7a soit =E7a, r/m8 and imm8, =E7a a l'air de passe=
r, de=20
m=EAme que r/m16 and imm16 ...

D'apr=E8s la description de l'instruction AND, =E0 la page suivante,=20
l'assembleur envoie le r=E9sultat dans le premier op=E9rande (destination=
).=20
Donc, si on a deux op=E9randes de m=EAme taille et un r=E9sultat de taill=
e=20
double, j'ai comme l'impression que l'explication serait =E0 chercher du =

c=F4t=E9 de l'impl=E9mentation, en l'occurrence sous csharp ?

23-Nov-09 07:44 AM

Ou peut-être d'abord du côté du code MSIL sous-jacent ou de la spéc du
langage ? Pour l'instant, je n'ai pas encore trouvé ou ce point particulier
est documenté...

--
Patrice

23-Nov-09 06:26 PM

Patrice a =E9crit, le 23/11/2009 13:44 :
ille=20
du=20
=E9c du=20
culier=20

J'avoue que je ne me repr=E9sentais pas, au d=E9part, o=F9 allait nous am=
ener=20
ma question.
Bon, pour le moment, on va juste t=E2cher de se garder un neurone pour se=
=20
rappeler qu'une combinaison bit =E0 bit, en csharp, peut donner un=20
r=E9sultat de taille diff=E9rente des donn=E9es de d=E9part (et qu'en cas=
de=20
doute on a des fonctions comme typename pour en avoir le c=9Cur net).

Et puis le jour o=F9 l'=E9clair jaillira sur l'explication, =E7a va bien =
finir=20
par se savoir :)

Merci en tout cas d'avoir =E9clair=E9 ma lanterne.

24-Nov-09 12:23 AM

Pour ?tre plus pr?cis dans la formulation, ce serait plut?t que les
op?rateurs bit ? bit ne sont d?finis que pour les int, les ushort ?tant
convertis implicitement en int lorsqu'on leur applique l'op?rateur.

24-Nov-09 05:58 AM

Christophe Lephay a =E9crit, le 24/11/2009 06:23 :
es=20
=E9tant=20

J'ai l'impression que =E7a, ce n'est pas pr=E9cis=E9 ici
http://msdn.microsoft.com/fr-fr/library/sbf85k1c%28VS.80%29.aspx

Il m'avait sembl=E9 avoir cit=E9 un document qui indiquait sur quels type=
s=20
=E9tait d=E9fini l'op=E9rateur, mais peut-=EAtre bien que c'=E9tait pour =

l'assembleur finalement (d'ailleurs c'est un peu logique, si j'avais=20
trouv=E9 une doc je l'aurais appliqu=E9e donc on n'aurait pas eu tout =E7=
a =E0=20
raconter).

Est-ce qu'on trouve une doc plus compl=E8te =E0 ce sujet, que j'aurais ma=
l=20
cherch=E9e, ou c'est des trucs qu'il faut savoir, comme =E7a, en les ayan=
t=20
acquis au hasard des lectures ?

25-Nov-09 02:11 AM

Trouv? ?a "Any operation performed on types sbyte, byte, short, or ushort
return int values" ici http://www.csharp-station.com/tutorials/Lesson02.aspx

28-Nov-09 04:12 AM

Christophe Lephay a =E9crit, le 25/11/2009 08:11 :
e=20
mal=20
yant=20


Ah, ben on dirait que voil=E0 une piste int=E9ressante :)