operator << dans #define

Version imprimable

24/10/2009, 23h12
Charlie111

operator << dans #define
Bonjour,

en regardant le code exemple des NxController du moteur PhysX j'ai bloqué sur un problème de syntaxe :
Il y a cette ligne dans le programme d'exemple :
Code:

1 2 3 4 5 6 7 8 9 enum CollisionGroup { GROUP_NON_COLLIDABLE, GROUP_COLLIDABLE_NON_PUSHABLE, GROUP_COLLIDABLE_PUSHABLE, }; #define COLLIDABLE_MASK (1<< GROUP_COLLIDABLE_NON_PUSHABLE)
Qu'y a-t'il dans COLLIDE_MASK ?? à quoi sert << ??

Merci d'avance !

++

Charlie
24/10/2009, 23h19
JulienDuSud

Collide Mask contiendra le mask binaire 10.

<< appliqué sur des entiers est un opérateur qui agit directement sur les bits, en les déplacant.

Exemple:

Code:

1 << 2

Veut dire: tu prend la représentation binaire de 1 (00000001) et tu le déplace 2 fois à gauche.

Donc le nombre devient:
00000100

ce qui représente 4.

Dans l'autre sens, c'est pareil:

00100000 >> 2
devient donc
00001000

attention à la perte de donnée

(00000001 >> 1) << 1 ça donne 0 car 0 << X donne toujours 0.
25/10/2009, 17h24
koala01
Salut,

On peut ajouter une précision sur le fonctionnement des énumérations:

Par défaut (comprend: en dehors de toute indication de valeur contraire), la première valeur énumérée d'une énumération vaut... 0 et toute valeur énumérée vaut... la valeur énumérée précédente +1.

Cela signifie que, dans l'exemple que tu donne:
- GROUP_NON_COLLIDABLE vaut 0
- GROUP_COLLIDABLE_NON_PUSHABLE vaut 1
- GROUP_COLLIDABLE_PUSHABLE vaut 2
Maintenant, comme l'a si bien indiqué JulienDuSud, l'opérateur << provoque le décalage des bits vers la gauche du nombre de bit correspondant à ce qui se trouve après l'opérateur.

De ce fait, le défine remplacera
- COLLIDABLE_MASK (1<< GROUP_NON_COLLIDABLE) par la valeur binaire 00000001 (soit... 1 en décimal)
- COLLIDABLE_MASK (1<< GROUP_COLLIDABLE_NON_PUSHABLE) par la valeur binaire 00000010 (soit 2 en décimal)
- COLLIDABLE_MASK (1<< GROUP_COLLIDABLE_PUSHABLE) par la valeur binaire 00000100 (soit 4 en décimal)
Comme il s'agit d'une directive de définition destinée au préprocesseur, tu peux estimer que, chaque fois que tu rencontre COLLIDABLE_MASK(1<< un des termes énumérés), cela revient à écrire dans le code respectivement 1, 2 ou 4, mais avec des valeurs plus "parlantes" ;)