Bitoperationen

[Aphton]

Zitat von Dunkelbunt27:

(...) 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"