Bit de décalage N bits

Question

Bonjour rapide question concernant le décalage de bits

J'ai une valeur dans HEX = new byte [] {0x56, 0xAF};

qui est 0101 0110 1010 1111

je veux les n premiers bits, par exemple 12

puis déplacer hors du restant 4 (16-12) pour obtenir 0000 0101 0110 1010 (1386 déc)

Je ne peux pas enrouler ma tête autour d'elle et la rendre évolutive pour n bits.

Merci!

Answer 1

Vous pouvez utiliser un BitArray, puis copier facilement chaque bit vers la droite, en commençant par la droite.

http://msdn.microsoft.com/en-us/library/system.collections.bitarray_methods.aspx

Answer 2

vous voulez quelque chose comme ...

var HEX = new byte[] {0x56, 0xAF}; 
var bits = new BitArray(HEX); 
int bitstoShiftRight = 4; 
for (int i = 0; i < bits.Length; i++) 
{ 
    bits[i] = i < (bits.Length - bitstoShiftRight) ? bits[i + bitstoShiftRight] : false; 
} 
bits.CopyTo(HEX, 0); 

Answer 3

Si vous avez Kbits au total, et que vous voulez le "premier" (comme dans le plus significatif) de n bits, vous pouvez tout simplement droit changer les temps de kn. Les derniers k-n bits seront supprimés, par sorte de "tomber" de la fin, et le premier n sera déplacé vers le côté le moins significatif.

Answer 4

Répondre en utilisant la notation de type C, en supposant bits_in_byte est le nombre de bits dans un octet déterminé ailleurs:

int remove_bits_count= HEX.count*bits_in_byte - bits_to_keep; 
int remove_bits_in_byte_count= remove_bits_count % bits_in_byte; 

if (remove_bits_count > 0) 
{ 
    for (int iteration= 0; iteration<min(HEX.count, (bits_to_keep + bits_in_byte - 1)/bits_in_byte); ++iteration) 
    { 
     int write_index= HEX.count - iteration - 1; 
     int read_index_lo= write_index - remove_bits_count/bits_in_byte; 

     if (read_index_lo>=0) 
     { 
      int read_index_hi= read_index_lo - (remove_bits_count + bits_in_byte - 1)/bits_in_byte; 

      HEX[write_index]= 
       (HEX[read_index_lo] >> remove_bits_in_byte_count) | 
       (HEX[read_index_hi] << (bits_in_byte - remove_bits_in_byte_count)); 
     } 
     else 
     { 
      HEX[write_index]= 0; 
     } 
    } 
} 

En supposant que vous écrasez le tableau original, vous prenez essentiellement chaque octet que vous écrivez à et à comprendre les octets qu'il obtiendrait ses bits décalés. Vous allez de la fin du tableau à l'avant pour vous assurer de ne jamais écraser les données que vous aurez besoin de lire.

Answer 5

Il y a quelque i codé ces deux fonctions, la première on déplace un byte [] un montant spécifié de bits vers la gauche, la seconde fait de même vers la droite:

Maj gauche:

public byte[] ShiftLeft(byte[] value, int bitcount) 
{ 
    byte[] temp = new byte[value.Length]; 
    if (bitcount >= 8) 
    { 
     Array.Copy(value, bitcount/8, temp, 0, temp.Length - (bitcount/8)); 
    } 
    else 
    { 
     Array.Copy(value, temp, temp.Length); 
    } 
    if (bitcount % 8 != 0) 
    { 
     for (int i = 0; i < temp.Length; i++) 
     { 
      temp[i] <<= bitcount % 8; 
      if (i < temp.Length - 1) 
      { 
       temp[i] |= (byte)(temp[i + 1] >> 8 - bitcount % 8); 
      } 
     } 
    } 
    return temp; 
} 

décalage à droite:

public byte[] ShiftRight(byte[] value, int bitcount) 
{ 
    byte[] temp = new byte[value.Length]; 
    if (bitcount >= 8) 
    { 
     Array.Copy(value, 0, temp, bitcount/8, temp.Length - (bitcount/8)); 
    } 
    else 
    { 
     Array.Copy(value, temp, temp.Length); 
    } 
    if (bitcount % 8 != 0) 
    { 
     for (int i = temp.Length - 1; i >= 0; i--) 
     { 
      temp[i] >>= bitcount % 8; 
      if (i > 0) 
      { 
       temp[i] |= (byte)(temp[i - 1] << 8 - bitcount % 8); 
      } 
     } 
    } 
    return temp; 
} 

Si vous avez besoin de plus amples explications s'il vous plaît commenter cela, je puis éditer mon message pour la clarification ...