Comment désactiver certains bits tout en ignorant les autres, en utilisant seulement les opérateurs au niveau du bit

J'ai cherché pour cela, mais mes résultats n'ont pas été satisfaisants, probablement en raison de combien il est difficile de parole. J'ai un seul objet, state, qui est un byte qui représente les parties de mon objet doivent être rendus lorsqu'on les observe, et une méthode, disableParts(byte partsToDisable), qui s'éteint tous les bits dans state qui sont dans partsToDisable. Comment puis-je obtenir cette fonctionnalité dans les opérations bit à bit? (c'est seulement à l'aide de AND, OR, XOR, NOT, LSHIFT, ARSHIFT, LRSHIFT, PLUS, MINUS, MULTIPLY, et/ou DIVIDE de base et les fonctions du programme tels que les boucles et les instructions de branchement)

Pour un peu de clarté, voici une représentation visuelle de mon fonctionnalités souhaitées:

  0010 0101 (current state, 37 in this example)
? 1010 0010 (bits to disable, -94 in this example)
============
  0000 0101 (new state, 5 in this example)

et un mannequin de classe (en Java, car c'est la façon dont je pense, mais la solution peut être n'importe quelle langue ou de la pseudo-code):

class BitThoughts
{
  byte state;

  public void doIt()
  {
    state = 0b00100101;
    System.out.println("Initial state: " + state);

    disableParts(0b10100010);

    if (state == 0b00000101)
      System.out.println("Success! New state is " + state);
    else
      System.out.println("Failure! New state is " + state);
  }

  public void disableParts(byte partsToDisable)
  {
    //Do magic to state
  }
}

Réponse

Seulement donc pas de derps aussi dur que j'ai fait... voici la réponse:

   0010 0101 (current state, 37 in this example)
& ~1010 0010 (bits to disable, -94 in this example)
=============

becomes:

   0010 0101 (current state: 37)
&  0101 1101 (inverted bits to disable: 93)
=============
   0000 0101 (new state, 5 in this example)

et la solution en Java:

public void disableParts(byte partsToDisable)
{
  state &= ~partsToDisable;
}
en.wikipedia.org/wiki/Bitmask#Masking_bits_to_0.
... attendre... derp... vous dites que c'est un simple NAND? facepalm

OriginalL'auteur Supuhstar | 2012-01-22

  1. 28

    Ce que vous devez faire est d'inverser les bits (bit à bit) dans la partsToDisable si vous vous retrouvez avec un masque où la les 1 sont les bits à être laissé seul et le 0 sont les bits d'être éteint. Ensuite, ET ce masque avec la valeur de l'état.

    public void disableParts( byte partsToDisable)
{
    state = state & (~partsToDisable);
}

    OriginalL'auteur Andrew Cooper

  2. 1

    Si vous venez juste d'inverser les bits de l'parties, vous pouvez simplement ET avec l'état

     void disableParts(byte parts) {
     byte invertOfParts = 0b11111111 - parts;
     state &= invertOfParts
 }

    OriginalL'auteur Amir Pashazadeh