Bitoperationen

[Dunkelbunt27]

Hallo Delphi-PRAXIS,

diesmal sind die "Lehrer" unter euch gefragt.
Ich bin sehr unerfahren mit Bitoperationen, möchte es aber unbedingt lernen/benutzen. Für einige von euch ist es bestimmt das einfachste von der Welt, also bitte korrigiert mich und schreit wenn ich völlig falsch liege.
Ich habe:

Code:

Attribut : byte;

Das möchte ich in 3 Bits unterteilen, also sodass ich Attribut1 (0,0,0), Attribut2 (0,0,1), Attribut3 (0,1,0) usw. Ich brauche so 7-8 verschiedene Möglichkeiten. Wie lege ich das so an?

Aber jetzt hatte ich irgendwann was gelesene, dass man daraus $00 macht und damit arbeitet... Wie funktioniert das nun wieder?
Was bringt es shift left (shl) und shift left (shr) zu benutzen... Geht es hierbei wieder nur um Ressourcensparen?

Seid geduldig mit mir ;)

FG Dunkelbunt

[himitsu]

Hexadezimalzahlen (dein $xx) wie man Dezimal in Hexadezimal umwandelt, kannst du bestimmt überall erfahren.

$00, $01, $02 ... $07
oder eben doch einfach dezimal 0 bis 7 nutzen

Statt deinem Byte und bei dieser Bitfolge (falls ich sie richtig erkannt hab) kannst du auch Folgendes nehmen:

Delphi-Quellcode:

TMyType = (Attribut1, Attribut2, Attribut3, ... , Attribut8);

.

PS: Bei 3 Bit und 8 Möglichkeiten kommt man mit Binäroperationen eh nicht so gut voran.
Hier ist ein Cast besser ... siehe den ENUM vom Anfang oder eben ganz einfach die Zahlen von 0 bis 7.

[Dunkelbunt27]

Danke erstmal,....
wie lege ich überhaupt fest aus wievielen Bit meine Zahl besteht?
Momentmanl... wenn ich Byte nehme ebsteht es ja automatsich aus 8 bit..... denkfehler

[himitsu]

es kommt darauf an, wie du deine Werte kodieren möchstest.

Du kannst die Werte z.B. im Zweierkomplement minimal kodieren (also kleinstmögliche Bitanzahl).
Oder binär jeden Wert in einem einzelnem Bit.
Oder sonstwie.

Wenn du jeden wert in einem Bit kodierst, dann machen sich Bitvergleiche natürlich einfacher und man kann sogar alle Werte zusammen in einer Variable unterbekommen (SET).


Es kommt also erstmal darauf an, was genau du vor hast.

[Dunkelbunt27]

Hallo,

perfekt wäre alle Werte in einer Variable zu kodieren. Dann könnte ich mir die 8 Bit aufteilen.

[himitsu]

Eine Variable ist in Delphi immer ganze 1, 2, 4 oder 8 Byte groß.
Oder eben eine Mischung daraus (Records/Objekte).

Wie gesagt, es gibt mehrere Varianten 8 Werte in einer Variable zu speichern .... es kommt allerdings darauf an was man damit erreichen will ... jenachdem eignet sich die einer oder andere Variante mehr dafür.

[Aphton]

Zitat:

Zitat von Dunkelbunt27 (Beitrag 1083301)

(...) sodass ich Attribut1 (0,0,0), Attribut2 (0,0,1), Attribut3 (0,1,0) usw. Ich brauche so 7-8 verschiedene Möglichkeiten (...)

Ich weiß zwar nicht, was du mit Möglichkeiten meinst, aber ein Byte hat nur einen "Umfang" von 8 Stellen > 00000000 - 8 Stellen wobei jede Stelle 2 Zustände annehmen kann -> 1 oder 0.
Das ergibt letzendlich 2^8 (= 256) Möglichkeiten, was wiederum einem Byte entspricht.

So, zu den einzelnen Bitoperationen:
OR
Per Or kannst du Bits verknüpfen, wobei gilt: mindestens ein Zustand von 2 muss 1 sein, damit letzendlich der Gesamtzustand 1 ist:
0 or 0 = 0
1 or 0 = 1
0 or 1 = 1
1 or 1 = 1

AND
Per And verknüpfst du wie folgt: es müssen beide Zustände 1 sein, damit der Gesamtzustand 1 ist:
0 and 0 = 0
1 and 0 = 0
0 and 1 = 0
1 and 1 = 1

XOR
Auch exklusives Or: es muss nur einer der beiden Zustände 1 sein:
0 xor 0 = 0
1 xor 0 = 1
0 xor 1 = 1
1 xor 1 = 0

SHL
Shift Left: verschiebt die Bits Y nach links um X Bits: Y shl X
10101101 shl 1 = 01011010
01 shl 2 = 100

SHR
Shift Right: verschiebt nach rechts:
10 shr 1 = 01
01 shr 1 = 00

Dann gibts noch ROL und ROR. Diese "Rollen" die Werte nach L oder R. Rollen im Sinne von - was hinten ist und normalerweise abgeschnitten wird, kommt an den Anfang:
1100 rol 1 = 1001
1001 rol 1 = 0011

Sofern du das verstanden hast, gehts hier weiter:
Sagen wir, du willst von einem Byte die Least Significant Bits beibehalten und die restlichen ignorieren/wegbringen
(kurz angemerkt: die 4 Least Significant Bits sind 0000XXXX die mit X gekennzeichnet).
Dann gehst du wie folgt vor:
0000XXXX and
00001111
--------
////XXXX
ganz egal, was in X steht, der Wert bleibt erhalten und die restlichen Werte gehen verloren. Auch wenn da statt 0 etwas andere drin stehen würde.

Nun musst du nur noch mehr wissen, wie man den dezimalen Wert binär darstellt. Dazu einfach mal googlen oder so.

Ein praktisches Beispiel:

Delphi-Quellcode:

type
  TBitRange = 0..7;
  TBitState = Boolean;
  TBitByte  = record
  private
    FValue: Byte;
    function GetBits(BitIndex: TBitRange): TBitState;
    procedure SetBits(BitIndex: TBitRange; const Value: TBitState);
    procedure SetValue(const Value: Byte);
  public
    property Value: Byte read FValue write SetValue;
    property Bits[BitIndex: TBitRange]: TBitState read GetBits write SetBits; default;
    function AsString(): String;
  end;


const
  BitChar   : Array[TBitState] of Char  = ( '0', '1' );
  BitTable  : Array[TBitRange] of Byte  = ( 1, 2, 4, 8, 16, 32, 64, 128 );

{ TBitByte }

function TBitByte.AsString: String;
var
  i: TBitRange;
begin
  SetLength( Result, 8 );
  for i := 0 to 7 do
    Result[8-i] := BitChar[Bits[i]];
end;

function TBitByte.GetBits(BitIndex: TBitRange): TBitState;
begin
  Result := FValue and BitTable[BitIndex] > 0;
end;

procedure TBitByte.SetBits(BitIndex: TBitRange; const Value: TBitState);
begin
  FValue := FValue or BitTable[BitIndex];
end;

procedure TBitByte.SetValue(const Value: Byte);
begin
  FValue := Value;
end;

Demo

Delphi-Quellcode:

var
  i: TBitRange;
  B: TBitByte;

begin
  for i := 0 to 3 do
    B[i] := True;
  Writeln( B.Value, ' - ', B.AsString );
  Readln;
end.

ergibt "15 - 00001111"

[Dunkelbunt27]

Danke, super.
Damit kann ich was anfangen :)

EDIT:
Wegen der Vollständigkeit:

Delphi-Quellcode:

function IntToBin(Int: Integer): String;
var
  i : Integer;
begin
  Result := '';
  for i := 7 downto 0 do
  Result := Result + IntToStr((Int shr i) and 1);
end;

function BinToInt(Binary: String): Integer;
var
  i : Integer;
begin
  Result := 0;
  for i := Length(Binary) downto 1 do
  Inc(Result, StrToInt(Binary[i]) * 1 shl (Length(Binary) - i));
end;

EDIT2:
Bin etwas verwirrt... wollte eigentlich nur Schruftfarben mit Bits kodieren....

FG Dunkelbunt

[Dunkelbunt27]

Wer das Problem mit mir teilt:
http://www.delphipraxis.net/95180-ef...bitmasken.html
ein gutes Tutorial von DeddyH, danke an dieser Stelle.

FG Dunkelbunt

[DeddyH]

Danke für die Blumen :D