Bits ausm Integer

[PhilmacFLy]

Hoi Dp

ich hab folgendes Problem: Ich hab einen Integer, brauch aber von dem nur die ersten 12 Bit und die zweiten 12. Ich hab schon gescuht, aber alles was ich gefunden habe, hat mir nicht wirklich weiter geholfen.

[Tryer]

MyInt and $FFF
(MyInt shr 12) and $FFF

[PhilmacFLy]

Und FFF weil FFF 2^12 oder?

[Neutral General]

Ja.

Eine Hexadezimalziffer = 4 Bit.

[Tryer]

Nein, weil $FFF = 2^12 - 1 = 1111_1111_1111b.
Durch das "And" werden alle anderen Bits ausgeblendet.

[SirThornberry]

deutlicher wird es wenn man die führenden Nullen mit schreibt

Delphi-Quellcode:

(MyInt shr 12) and $00000FFF

$00000FFF = 00000000000000000000111111111111

Hier mal das ganze falls bei MyInt jedes zweite bit gesetzt ist:

Code:

MyInt        = 10101010101010101010101010101010

Code:

MyInt shr 12 = 00000000000010101010101010101010
$00000FFF    = 00000000000000000000111111111111
-----------------------------------------------
mit and      = 00000000000000000000101010101010

[PhilmacFLy]

ok so vielo ist mir klar.
Die zweiten 12 les ich dann praktische so aus

Delphi-Quellcode:

MyInt shr 24 = 00000000000010101010101010101010 
$00FFF000    = 00000000111111111111000000000000 
----------------------------------------------- 
mit and      = 00000000000010101010000000000000

oder?

[SirThornberry]

das war schon zum auslesen der 2ten 12.
Wenn man die ersten 12 haben will braucht man nicht zu shiften.
Durch das shiften werden die 1ten 12 nach rechts weg geschoben und die nächsten Bits rücken von links her nach.

Wobei es jetzt sein kann das ich was falsches erzähle je nachdem was du als die "ersten" 12 ansiehst.
Eine 1 sieht ja wie folgt aus:

Code:

00000000000000000000000000000001

ist das gesetzte Bit für dich jetzt das erste oder das letzte?

[PhilmacFLy]

Das erste, weil das ist ja 2^1

[SirThornberry]

dann stimmt meine Antwort - einfach das shiften weg lassen für die ersten 12.

Das ganze mal am Beispiel der 1 für MyINt

Code:

MyInt mit Wert 1 = 00000000000000000000000000000001 
$00000FFF        = 00000000000000000000111111111111 
--------------------------------------------------- 
mit and          = 00000000000000000000000000000001

würdest du shiften (shr), würde das 1te Bit ja nach rechts raus geschoben werden.

[Tryer]

Zitat:

Zitat von PhilmacFLy

Das erste, weil das ist ja 2^1

Das "erste" Bit ist das Bit 0, da es für 2^0 = 1 steht.
erst das zweite Bit (das Bit 1) hat die Wertigkeit 2^1 = 2.
Zählt man die Bits ab, dann ist also das Bit 12 das 13. Bit. Da vertut man sich leicht, aber das ist nunmal die Basis auf der die EDV funktioniert.

Folgerichtig besteht unsere Maske die wir per "and" über die Zahl legen ja auch aus den Bit´s 0 bis 11, also 2^12 - 1. Das Bit 12, was für 2^12 gesetzt wäre ist nur ein Bit, wir wollten aber das alle niederwertigeren Bits gesetzt sind - das ist nunmal der Wert davor (-> -1).

"shr Anzahl" verschiebt Anzahl Bits nach rechts, und macht somit aus den Bit´s 12..23 die Bits 0..11. Wie man die Auswertet wissen wir ja schon, das ist wieder die AND - Maske.

Grüsse, Dirk

PS: Deswegen heißt es ja so schön: es gibt 10 Gruppen von Menschen: welche die binär lesen können, und welche die es nicht können.

[PhilmacFLy]

jo ich weiss ich brauch ja bit 0-11 deswegen 12 nicht 13 :D

[DeddyH]

Wenn ich gerade keinen Denkfehler mache, ginge das recht einfach so:

Delphi-Quellcode:

ErsteZwoelfBit := Zahl and (1 shl 12 - 1);
NaechsteZwoelfBit := (Zahl shr 12) and (1 shl 12 - 1);

[Tryer]

Hattu richtig :thumb: :mrgreen:
(1 shl 12) - 1 ist auch $FFF

[DeddyH]

Zitat:

Zitat von Tryer

Hattu richtig :thumb: :mrgreen:
(1 shl 12) - 1 ist auch $FFF

Klar, aber wozu selber rechnen? Da bin ich viel zu faul zu :mrgreen:

[PhilmacFLy]

Jo ok, is aber jetzt schon so eingebunden und es geht, von daher werd ichs auch so lassen

[DeddyH]

Da spricht ja auch nichts dagegen.