Retour aux sources : du binaire pour la gestion des droits

[JWHSmith]

-----

[srm]

A noter que ça s'applique pas que pour les droits, mais pour tout ce qui a un grand nombre de paramètre du type booléen.

[Talus]

les masques binaire (le nom de cette technique) est très utiliser lorsque que tu fait de la programmation système en C (surtout sous linux)
mais tu n'est pas obliger d'utiliser une écriture en hexa pour tes constante tu les mettre en décimal ça marche tout aussi bien

[Xenos]

Je les ai déjà vu appelés "flags", ces masques binaires.

Au lieu de 0x002, 0x004 etc, qui sont certes très classes pour l'obfuscation mais qui sont très peu pratiques pour la lecture et la maintenance, on peut utiliser (suivant les langages), la syntaxe

1<<N

où << est l'opérateur de décalage binaire. En d'autres termes, le mot binaire (ex: 010101101) sera décalé de N bits vers la gauche, le trou étant complété par des 0 et les N premiers bits étant perdus (010101101 << 5 --> 010101101 00000 --> 01010 110100000 --> 110100000).
Donc, 1<<N correspond à la mise à 1 de tous les bits d'un mot, sauf le N ème, ce qui permet d'écrire:

can_do_this = (1 << 1); //Droit déterminé par le "flag" 1, aka, le bit 1
can_do_that = (1 << 2); //Droit déterminé par le "flag" 2, aka, le bit 2
can_do_this2 = (1 << 3); //Droit déterminé par le "flag" 3, aka, le bit 3
can_do_thattoo = (1 << 4); //Droit déterminé par le "flag" 4, aka, le bit 4

Il devient alors plus facile de savoir quel bit gère quoi et on évite des erreurs de calcul.

@Thalus
En hexadécimal, on a:
0x01 0x02 0x04 0x08 0x10 0x20...
En décimal
1 2 4 8 16 32 64

Pour les grands nombres, cela sera donc plus facile d'entrer l'hexa que le décimal:
128 256 512 1024 2048 4096 8192 16384 32768 65536 ... mais après, c'est dur de les connaitre par coeur!
0x0080 0x0100 0x0200 0x0400 0x0800 0x1000 0x2000 0x4000 0x8000...
Facile de compléter les nombres, sans même connaitre la valeur décimale par coeur

En binaire, on peut le faire également, mais c'est long (b1 b10 b100 b1000...)
D'où mon conseil: pour définir qu'une constante C est le mot binaire où tous les bits sont à 0 sauf le N-eme, utilisez "1<<N".


----

Note: certains SGDB résolvent peut-être d'eux même ce problème: si plusieurs colonnes de type "bool" se suivent, leur valeur est peut-être stockée dans un seul "champ" binaire (aka, si j'ai 8 colonnes de type "bool", cela ne prend qu'un octet de donnée dans la BDD, alors que si j'ai 9 colonnes, cela prend 2 octets car tout octet entamé est complété).

[niahoo]

J'utilise souvent cette technique, par contre je ne comprends pas vos remarques :

Pourquoi initialiser les constantes avec des hexadécimaux. Vous devez être balaises pour retenir toutes ces puissances de 2 en hexa. Par contre en notation normale je sais aller juqu'à 4096 (pas terrible :S mais je n'ai jamais eu besoin d'autant de valeurs)

Je comprends pas l'utilisation de la rotation. Chez moi (1 << 1) ça fait 2 du coup c'est pas du tout opti côté mnémotechnique.


>>> Pour les grands nombres, cela sera donc plus facile d'entrer l'hexa que le décimal:

Ben oui mais bon, si on utilise des constantes c'est justement pour pas retenir les chiffres de toute façon.

---

Donc, 1<<N correspond à la mise à 1 de tous les bits d'un mot, sauf le N ème

non plus, ça décale juste ...

---

En fait loin de moi l'idée d'être antipathique, mais ton post c'est n'importe quoi en fait.

[Xenos]

*<<N décale les bits de * à gauche de N bits, en paddant le trou avec des zéros.
1 est le nombre entier 1, codé en binaire 000....01
Donc, 1<<N est le décalage de 000...001 de N bits à gauche, donc, 0.000100..00 avec N zéros à la fin. C'est donc bien la mise à 1 du N-ème bit (je compte comme les informaticiens: en partant de zéro, aka le bit 0 est le bit le plus à droite).

D'où la remarque "initialiser avec des hexadécimaux? C'est peu pratique. Initialiser avec l'opérateur de décalage de bit est plus souple".

"ton post": de quel message parles-tu?

-----
Au fait

Code PHP :

<?php 

return (!((int)$right & $this->operator)) ? false : true; 

[niahoo]

C'est ton post qui dit n'importe quoi. Mais peut-être que je me trompe, ça ne me choquerais pas.

"Donc, 1<<N correspond à la mise à 1 de tous les bits d'un mot, sauf le N ème"

Erreur. 1 << 3 ça fait '1000' en binaire, donc c'est pas le 3eme qui est à '1', c'est le N+1.

can_do_this = (1 << 1); //Droit déterminé par le "flag" 1, aka, le bit 1

Erreur, 1 << 1 ça fait deux, soit '10' en binaire, c'est le flag 2, le bit 2.

1<<N correspond à la mise à 1 de tous les bits d'un mot, sauf le N ème, ce qui permet d'écrire ...

Erreur, ça ne mets pas tous les bits à 1 sauf le Nième, ça ne fait que décaler de N bits.


Voilà mais peut-être que dans d'autres langages ça se comporte comme tu le dis. J'ai cependant de gros doutes.

[niahoo]

Ah j'ai relu et je vois que tu comptes les bits en partant de l'indice 0. Du coup on peut parler du Nième bit effectivement, mais ça embrouille plus qu'autre chose. Mais là c'est une histoire de goûts

[Xenos]

Eyuup, tout viens du fait que je démarre de 0

sauf peut-être le "1<<N correspond à la mise à 1 de tous les bits d'un mot" où mon "d'un mot", est de trop...
Oui, * << N décale tous les bits d'un mot de N rangs, ca, t'as raison (j'ai jamais pensé le contraire, j'espère ne pas l'avoir dit), mais si *=1, alors 1<<N revient à mettre tous les bits à 1 sauf le N-eme (ou N+1 eme), puisque le "mot" est composé que de zéros, sauf le 0eme bit.

[archANJS]

http://i.imgur.com/oo35Z.gif