Wie kann ich extrahieren von bits von der 32 bit-Zahl

Habe ich nicht viel Kenntnisse in C und im stecken mit einem problem da mein Kollege ist auf Urlaub.

Ich habe eine 32 bit-Zahl, und ich habe zum extrahieren von bits aus. Ich habe Sie durch ein paar threads, aber ich bin mir immer noch nicht klar, wie dies zu tun. Ich wäre sehr dankbar, wenn mir jemand helfen kann.

Hier ist ein Beispiel von, was ich tun muss:

Übernehmen hex-Zahl= 0xD7448EAB.
In binären= 1101 0111 0100 0100 1000 1110 1010 1011
Ich benötige zum extrahieren von 16 bits, und die Ausgabe Wert. Ich möchte die bits 10 bis 25.

Den unteren 10 bits (Dezimal) werden ignoriert. d.h.,10 1010 1011 werden ignoriert.

Und die oberen 6 bits (Überlauf) werden ignoriert. d.h., 1101 01 werden ignoriert.

Den verbleibenden 16 bits der Daten muss der Ausgang ist 11 0100 0100 1000(die zahlen in Kursiv sind nötig, da die Ausgabe).

Dies war ein Beispiel, aber ich werde immer unterschiedliche hex-zahlen, die alle die Zeit und ich brauche, um zu extrahieren die gleichen bits wie ich schon erklärt habe.

Wie löse ich dieses?

Danke.

Für dieses Beispiel würden Sie die Ausgabe 1101 0001 0010 0011, die 0xD123, oder 53,539 dezimal.

Brauchen Sie, um alles in binärer form? Oder würden Sie in der Lage sein, zum konvertieren des hex-Wert in Binär -, dann wandeln Sie die binären Wert in einen string. Sie könnten dann einfach den Teilstring, der Sie interessiert, und wandeln es wieder in Binär - /hexadezimal -, wie gebraucht.
Und (& - operator) Ihren Wert mit einer Maske, mit der die bits gesetzt, die Sie interessiert sind, dann rechts-shift der Folge (>> Betreiber) richten Sie Sie mit bit null.

InformationsquelleAutor user3267877 | 2014-02-03

2

Müssen Sie Masken zu erhalten, die bits, die Sie möchten. Masken sind zahlen, die Sie verwenden können, um zu sichten, die durch die bits in der Art und Weise, die Sie wollen (halten Sie die bits, löschen/löschen von bits, ändern, Nummern, etc.). Was Sie wissen müssen, sind die UND, ODER, XOR, NICHT, und die Verlagerung Operationen. Für das, was Sie brauchen, Sie müssen nur ein paar.

Wissen Sie verschieben sich: x << y verschiebt die bits von x *y Positionen nach Links*.

Wie man x bits auf 1 gesetzt, um: (1 << x) - 1

Wie man x bits auf 1 gesetzt, um, ausgehend von y zu y + x: ((1 << x) -1) << y

Oben ist die Maske für die bits, die Sie brauchen. So wollen Sie zum Beispiel 16 bits 0xD7448EAB, von 10 bis 25, müssen Sie die oben, für x = 16 und y = 10.

Und jetzt, um die bits, die Sie möchten, nur UND deine Nummer 0xD7448EAB mit der Maske vor, und Sie erhalten die maskierte 0xD7448EAB mit nur die bits, die Sie möchten. Später, wenn Sie wollen, gehen Sie durch jedes, müssen Sie verlagern Sie Ihr Ergebnis durch 10 zu der rechten und der Prozess jedes bit für bit (an position 0).

Die Antwort könnte ein bisschen länger sein, aber es ist besser zu gestalten als nur hard-Codierung mit 0xff oder was auch immer.

Hi webuster, ich fand deine ein wenig einfacher zu verstehen, so dass ich versuchte, die Berechnung der Werte, aber es scheint zu der Ausgabe falsche Ergebnis. Ich benutzte Programmierer Taschenrechner im hex-Modus. 1<<16 = 400000-1= 3fffff. Jetzt 3fffff << 10 = 3fffff0000 & D7448eab = D7440000 = 11010111010001000000000000000000 (Binär). Der Ausgang ist nicht das, was erforderlich ist. Lassen Sie mich wissen, wenn ich etwas falsch machen
(1 << 16) - 1 = ffff. Was du tust im Rechner ist, du bist Lsh-ing 1 mit 16 in HEX, die 22 im Dezimalsystem. Versuchen Lsh-ing 1 mit 10 hex (16-in-Binär -) und du erhältst das richtige Ergebnis.
Ich hab das auch und das Ergebnis ist das gleiche (1<<10)-1=ffff <<10 = ffff0000 & 0xD7448EAB = D7440000 = 11010111010001000000000000000000. Die ersten sechs bits werden ignoriert, und wenn Sie überprüfen, werden Sie nicht ignoriert, und daher das falsche Ergebnis. Die Ergebnisse, die ich brauche, ist 1101 0001 0010 0011
Sie machten die gleichen Fehler, Lsh-ing und Rsh-ing mit der Basis 16 nicht in dezimal. Lsh-ing mit 10 in HEX bedeutet die Verlagerung vom 16. Die Hex-Ziffer für die dezimal 10 ist A. Also auf dem Weg sollten Sie die shift-FFFF << a die Schritte sind (mit Bezug auf Taschenrechner): 1 << 10 ist, dann -1 => FFFF. Dann FFFF << A = 3FFFC00. Dann D7448EAB & 3FFFC00 ist 3448C00, die in Binär 1101 0001 0010 0011, wie man wollte.
Ohh wow, die Sinn macht. Vielen Dank für die Hilfe.

InformationsquelleAutor webuster
3

OK, hier ist, wie ich es schrieb:
```
#include <stdint.h>
#include <stdio.h>

main() {
    uint32_t in = 0xd7448eab;
    uint16_t out = 0;

    out = in >> 10; //Shift right 10 bits
    out &= 0xffff;  //Only lower 16 bits
    printf("%x\n",out);
}
```
Den in >> 10 verschiebt sich die Nummer 10 bits, die & 0xffff verwirft alle bits außer dem niederwertigen 16 bits.

Warum = und &= getrennt, statt mit = und & in der gleichen Aussage?
Einfacher zu Folgen, für einen Anfänger in C (es lassen Sie mich Kommentar jeder änderung) und & hat Präzedenzfall Probleme (die wirklich throw off someone wer kennt Sie nicht, die Seile C)
Wie würden Sie passen diese Lösung zu extrahieren unbekannter Reihe von bits? Wie eine Funktion extract(unsigned num, unsigned hi, unsigned lo) dass die Rendite der bits im Bereich hi zu lo von num?

InformationsquelleAutor samiam
1

Möchte ich die bits 10 bis 25.

Können Sie dies tun:
```
unsigned int number = 0xD7448EAB;
unsigned int value = (number & 0x3FFFC00) >> 10;
```
Oder so:
```
unsigned int number = 0xD7448EAB;
unsigned int value = (number >> 10) & 0xFFFF;
```
unsigned int Anzahl = 0xD7448EAB; unsigned int Wert = (Zahl & 0x3FFFC00) >> 10; dies ist absolut richtig. die einzige änderung, die erforderlich ist >>8 anstelle von >>10. Ich habe diese arbeiten. Danke
Mit >> 10 richtig ist für das, was Sie gefragt haben. Mit >> 8 würde Ihnen die bits 8 bis 23 statt, das ist nicht das, was Sie gefragt haben.

InformationsquelleAutor Remy Lebeau

Kombinierte ich die obersten 2 Antworten zu schreiben Sie ein C-Programm zum extrahieren von bits, die für jede Reihe von bits (nicht nur 10 bis 25) und einem 32-bit unsigned int. Die Art und Weise der Funktion ist, es gibt bits lo zu hi (inklusive)num.

#include <stdio.h>
#include <stdint.h>

unsigned extract(unsigned num, unsigned hi, unsigned lo) {
    uint32_t range = (hi - lo + 1);  //number of bits to be extracted
    //shifting a number by the number of bits it has produces inconsistent 
    //results across machines so we need a special case for extract(num, 31, 0)
    if(range == 32)
        return num;
    uint32_t result = 0;
    //following the rule above, ((1 << x) - 1) << y) makes the mask:
    uint32_t mask = ((1 << range) -1) << lo;
    //AND num and mask to get only the bits in our range
    result = num & mask;
    result = result >> lo; //gets rid of trailing 0s
    return result;
}
int main() {
    unsigned int num = 0xd7448eab;
    printf("0x%x\n", extract(num, 10, 25));
}

InformationsquelleAutor Catherine

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.