Masque (calcul)

Dans le de l'informatique, un masque est quelques données qui, avec une opération, sont employées afin d'extraire l'information stockée ailleurs.

Le masque le plus commun utilisé, également connu comme bitmask , extrait le statut de certain peu dans une corde ou un nombre binaire (un a mordu le champ ou la rangée de peu ). Par exemple, si nous avons la corde binaire 10011101 et nous voulons extraire le statut du cinquième peu comptant le long à partir du la plupart de peu significatif , nous emploierions un bitmask tel que 00001000 et emploierions l'opérateur du au niveau du bit AND . Rappelant que 1 ET 1 = 1, avec 0 autrement, nous trouvent le statut du cinquième peu, depuis 1001 1 101 ET 0000 1 000 = 0000 1 000

De même nous pouvons placer le cinquième peu en appliquant le masque aux données using l'opérateur du OR .

De même, nous pouvons employer un ordre s nombres binaire avec un morceau de données de longueur égale employées pour informer quant à quelles parties des données devraient être examinées. Avec de le de l'opération au niveau du bit (PAS X) ET Y, un dans le masque (X) instruit que les informations binaires ci-dessous (Y) devraient être ignorées, alors que s dans le masque (X) indiquent que les données ci-dessous (Y) doivent être examinées. Un type commun de masque de ce type est un masque de sous-réseau de , qui est associé à l'IP address du d'un dispositif et utilisé pour instruire un routeur que le peu de l'adresse indique la subdivision du réseau l'ordinateur est allumé et qui identifie l'ordinateur spécifique dans le sous-réseau.

Fonctions communes de bitmask

Peu de masquage à 1

Pour mettre certains bits à 1, nous employons l'opération du au niveau du bit OR . Rappel qui Y ou 1 = 1 et Y ou 0 = Y. Par conséquent, s'assurer un peu est allumé, nous OR il avec un 1. Pour laisser un peu seul, nous OR il avec un 0.

Peu de masquage à 0

Comme nous voyons en haut, il n'y a aucune manière de changer un peu du sur en outre de using l'opération de OR. Au lieu de cela, nous employons le au niveau du bit AND . Quand une valeur est ANDed avec un 1, le résultat est simplement la valeur originale, comme dans : Y ET 1 = Y. Cependant, quand nous AND une valeur avec 0, nous sommes garantis pour récupérer un 0 ainsi nous peut arrêter un peu par ANDing il avec 0 : Y ET 0 = 0. Pour laisser l'autre peu seul, simplement AND ils avec un 1.

Question du statut d'un peu

Vous pouvez également employer des bitmasks pour vérifier facilement l'état de peu individuel indépendamment de l'autre peu. Pour faire ceci, vous arrêtez simplement tout l'autre peu using au niveau du bit le AND en tant que discuté au-dessus de et voyez si la valeur en résultant est 0. Si elle est, alors le peu était éteint, mais si la valeur est n'importe quelle autre valeur, alors le peu était allumé. Ce qui fait ce si commode est que vous n'avez pas besoin de figurer dehors ce qu'est réellement la valeur, vous devez juste savoir que ce n'est pas 0.

Sélection des valeurs de peu

Jusqu'ici nous avons vu comment allumer le peu et arrêter le peu, mais pas tous les deux immédiatement. Que si nous ne nous inquiétons pas vraiment ce qu'est la valeur, nous connaissons-nous juste voulons-nous que soit-elle l'opposé de ce qu'est actuellement il ? Nous pouvons faire ceci using l'opération du XOR (exclusivité ou) . XOR renvoie le de 1 si et seulement si un nombre impair de peu sont 1. Par conséquent, si deux bits correspondants sont 1, le résultat sera un 0, mais si seulement un d'entre eux est 1, le résultat sera 1. Par conséquent nous pouvons inverser les valeurs du peu par XORing ils avec un 1. Si le peu original était 1, nous obtiendrons 1 XOR 1 = 0. Si le peu original était 0 nous obtiendrons 0 XOR 1 = 1. Noter également que le masquage de XOR est peu-sûr, signifiant qu'il n'affectera pas le peu démasqué parce que le Y XOR 0 = Y, juste comme un OR.

Arguments aux fonctions

Dans des langages de programmation tels que le C , masques de peu sont une manière utile de passer un ensemble d'arguments booléens appelés à une fonction. Par exemple, dans le OpenGL des graphiques api, il y a une commande, () glClear qui dégage l'écran ou d'autres amortisseurs. Il peut éclaircir à quatre amortisseurs (la couleur, la profondeur, l'accumulation, et les amortisseurs de pochoir), ainsi les auteurs d'api pourraient l'avoir fait prendre quatre arguments. Mais d'autre part un appel à lui regarderait le goût glClear (1.0) ; // ceci n'est pas comment réellement les travaux glClear et conduirait au code illisible. ce qui n'est pas très descriptif. Au lieu de cela il y a quatre champs définis de peu, GL_COLOR_BUFFER_BIT, GL_DEPTH_BUFFER_BIT, GL_ACCUM_BUFFER_BIT, et de GL_STENCIL_BUFFER_BIT et glClear () est déclaré As glClear vide (masque de GLbitfield) ; Alors un appel à la fonction ressemble à ceci glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) ; Intérieurement, une fonction prenant un bitfield comme ceci peut employer and logique pour extraire le peu individuel. Par exemple, une exécution () de glClear pourrait regarder le goût glClear vide (masque de GLbitfield) { si (masque et GL_COLOR_BUFFER_BIT) { Amortisseur clair de couleur de //. } si (masque et GL_DEPTH_BUFFER_BIT) { Amortisseur clair de profondeur de //. } si (masque et GL_ACCUM_BUFFER_BIT) { Amortisseur clair d'accumulation de //. } si (masque et GL_STENCIL_BUFFER_BIT) { Amortisseur clair de pochoir de //. } } Tandis qu'élégante, dans l'exécution la plus simple cette solution n'est pas le type-sûr. Un GLbitfield est simplement défini pour être un int unsigned, ainsi le compilateur permettrait un appel sans signification (à 42) glClear ou même (GL_POINTS) à glClear. Dans le C++ une alternative serait de créer une classe pour encapsuler l'ensemble d'arguments que glClear peut accepter. Cependant, une telle tentative de type sûreté serait au coût de la complexité et de l'exécution.

Voir également

Masque d'affinité de
Sous-réseau
Modification de configuration binaire

.

Random links:

Centre d'argile, Ohio | Analyse conjointe | Treize (film) | Beverly LaHaye | Le prologue et le conte du Prioress | Máscara_(computación)