Wie extrahiere ich bestimmte ‘n’ Bits einer 32-Bit-Ganzzahl ohne Vorzeichen in C?

Kann mir jemand sagen, wie man ‘n’ bestimmte Bits aus einer 32-Bit-Ganzzahl ohne Vorzeichen in C extrahiert.

Angenommen, ich möchte die ersten 17 Bits des 32-Bit-Werts; was soll ich tun?
Ich nehme an, ich soll den Modulo-Operator verwenden, und ich habe es versucht und konnte die letzten 8 Bits und die letzten 16 Bits als erhalten

unsigned last8bitsvalue=(32 bit integer) % 16
unsigned last16bitsvalue=(32 bit integer) % 32

Ist das richtig? Gibt es einen besseren und effizienteren Weg, dies zu tun?

Anstatt es als „extrahieren“ zu betrachten, betrachte ich es lieber als „isolieren“. Sobald die gewünschten Bits isoliert sind, können Sie damit machen, was Sie wollen.

Um einen beliebigen Satz von Bits zu isolieren, wenden Sie eine UND-Maske an.

Wenn Sie die letzten X Bits eines Werts benötigen, gibt es einen einfachen Trick, der verwendet werden kann.

unsigned  mask;
mask = (1 << X) - 1;
lastXbits = value & mask;

Wenn Sie eine Reihe von X Bits in der Mitte von ‘value’ isolieren möchten, beginnend bei ‘startBit’ …

unsigned  mask;
mask = ((1 << X) - 1) << startBit;
isolatedXbits = value & mask;

Hoffe das hilft.

Wenn Sie n Bits spezifisch möchten, können Sie zuerst eine Bitmaske erstellen und dann AND es mit Ihrer Nummer, um die gewünschten Bits zu nehmen.

Einfache Funktion zum Erstellen einer Maske von Bit a bis Bit b.

unsigned createMask(unsigned a, unsigned b)
{
   unsigned r = 0;
   for (unsigned i=a; i<=b; i++)
       r |= 1 << i;

   return r;
}

Sie sollten prüfen, ob a<=b.

Wenn Sie die Bits 12 bis 16 wollen, rufen Sie die Funktion auf und dann einfach & (logisches UND) r mit deiner nummer N

r = createMask(12,16);
unsigned result = r & N;

Wenn Sie möchten, können Sie das Ergebnis verschieben. Hoffe das hilft

Modul funktioniert, um (nur) untere Bits zu bekommen, obwohl ich denke value & 0x1ffff drückt “nimm die unteren 17 Bits” direkter aus als value % 131072und ist daher leichter zu verstehen, als dies zu tun.

Die obersten 17 Bits eines 32-Bit-Werts ohne Vorzeichen wären value & 0xffff8000 (wenn Sie möchten, dass sie immer noch an ihren Positionen oben sind), oder value >> 15 wenn Sie die oberen 17 Bits des Werts in den unteren 17 Bits des Ergebnisses haben möchten.

Es gibt eine einzige BEXTR (Bitfeldextrakt (mit Register)) x86-Anweisung auf Intel- und AMD-CPUs und UBFX auf ARM. Es gibt intrinsische Funktionen wie z _bextr_u32() (Link erfordert Anmeldung), die es ermöglichen, diese Anweisung explizit aufzurufen.

Sie implementieren (source >> offset) & ((1 << n) - 1) C-Code: erhalten n kontinuierliche Bits aus source beginnend bei der offset bisschen. Hier ist eine vollständige Funktionsdefinition, die Grenzfälle behandelt:

#include <limits.h>

unsigned getbits(unsigned value, unsigned offset, unsigned n)
{
  const unsigned max_n = CHAR_BIT * sizeof(unsigned);
  if (offset >= max_n)
    return 0; /* value is padded with infinite zeros on the left */
  value >>= offset; /* drop offset bits */
  if (n >= max_n)
    return value; /* all  bits requested */
  const unsigned mask = (1u << n) - 1; /* n '1's */
  return value & mask;
}

Zum Beispiel zu bekommen 3 Stückchen ab 2273 (0b100011100001) beginnt um 5-th Bit, rufen Sie an getbits(2273, 5, 3)—es extrahiert 7 (0b111).

Angenommen, ich möchte die ersten 17 Bits des 32-Bit-Werts; was soll ich tun?

unsigned first_bits = value & ((1u << 17) - 1); // & 0x1ffff

Vorausgesetzt CHAR_BIT * sizeof(unsigned) ist 32 auf Ihrem System.

Ich nehme an, ich soll den Modulo-Operator verwenden, und ich habe es versucht und konnte die letzten 8 Bits und die letzten 16 Bits abrufen

unsigned last8bitsvalue  = value & ((1u <<  8) - 1); // & 0xff
unsigned last16bitsvalue = value & ((1u << 16) - 1); // & 0xffff

Wenn der Offset wie in allen Ihren Beispielen in der Frage immer Null ist, brauchen Sie den allgemeineren nicht getbits(). Es gibt einen speziellen CPU-Befehl BLSMSK, der hilft, die Maske zu berechnen ((1 << n) - 1).

Wenn Sie die X letzten Bits Ihrer Ganzzahl benötigen, verwenden Sie a binäre Maske :

unsigned last8bitsvalue=(32 bit integer) & 0xFF
unsigned last16bitsvalue=(32 bit integer) & 0xFFFF

Dies ist eine kürzere Variante der akzeptierten Antwort: Die folgende Funktion extrahiert die Bits von bis einschließlich, indem sie eine Bitmaske erstellt. Nach dem Anwenden einer UND-Logik auf die ursprüngliche Zahl wird das Ergebnis verschoben, sodass die Funktion nur die extrahierten Bits zurückgibt. Übersprungene Index-/Integritätsprüfungen zur Verdeutlichung.

uint16_t extractInt(uint16_t orig16BitWord, unsigned from, unsigned to) 
{
  unsigned mask = ( (1<<(to-from+1))-1) << from;
  return (orig16BitWord & mask) >> from;
}

Bitweise UND Ihre Ganzzahl mit der Maske, die genau die Bits enthält, die Sie extrahieren möchten. Verschieben Sie dann das Ergebnis nach rechts, um die extrahierten Bits bei Bedarf neu zu positionieren.

unsigned int lowest_17_bits = myuint32 & 0x1FFFF;
unsigned int highest_17_bits = (myuint32 & (0x1FFFF << (32 - 17))) >> (32 - 17);

Bearbeiten: Letzteres positioniert die höchsten 17 Bits als die niedrigsten 17 neu; Dies kann nützlich sein, wenn Sie eine ganze Zahl „innerhalb“ einer größeren extrahieren müssen. Sie können die rechte Verschiebung weglassen (>>) falls dies nicht erwünscht ist.