Datentypen von String zu Byte und wieder zurück

[Michael II]

Hallo Graw,

du weisst doch wie man in der IDE den Debugger nutzt?

Du kannst damit bequem Zeile für Zeile durch dein Programm steppen und dabei beobachten wie sich die Werte deiner Variablen ändern und findest den/die Fehler in deinem Code so sicher sehr rasch.

In deinem Fall überwache die Ausdrücke PBuf, PBuf10, PBuf20 und setze einen Breakpoint bei deiner ersten Zeile und lass es laufen :-).

[Uwe Raabe]

Zitat:

Zitat von Graw (Beitrag 1369368)

Ist es so besser?

In (deinem) Delphi sind Strings 1-basiert. Daher besser so:

Delphi-Quellcode:

Delete(PBuf10, 1, 12);
Delete(PBuf20, 1, 12);
Delete(PBuf10, length(PBuf10) - 2, 3);
Delete(PBuf20, length(PBuf20) - 2, 3); // In deinem Code veränderst du übrigens PBuf10!

Du kannst auch Copy verwenden:

Delphi-Quellcode:

PBuf10 := Copy(PBuf10, 13, Length(PBuf10) - 15);
PBuf20 := Copy(PBuf20, 13, Length(PBuf20) - 15);

Oder das Ganze gleich in eine eigene Funktion kapseln:

Delphi-Quellcode:

function ClipString(const Value: string; Head, Tail: Integer): string;
begin
  result := Copy(Value, Head + 1, Length(Value) - (Head + Tail));
end;

PBuf10 := ClipString(PBuf10, 12, 3);
PBuf20 := ClipString(PBuf20, 12, 3);

[Olli73]

Delphi-Quellcode:

PBuf1 := Copy(PBuf10,13,Length(PBuf10)-15);

Edit: Habe übersehen, dass das schon oben steht.

[Luckie]

Warum nimmst du nicht einfach zwei Variablen, in denen du das erst mal zwischenspeicherst. Das macht den Code auch übersichtlicher.

[Graw]

Hat nun doch alles geklappt. Hatte meine Strings nicht richtig geschnitten.

Vielen Dank.

[Blup]

Ein anderer Weg, mit reinem Assembler geht das natürlich noch kompakter:

Delphi-Quellcode:

function Rol(const AValue: LongWord; const ACount: Byte): LongWord; register;
asm
  mov cl, dl
  rol eax, cl
end;

function IntConvert(A, B: LongWord): Int64;
var
  i: integer;
begin
  Result := 0;
  for i := 0 to 31 do
  begin
    Result := Result shl 1;
    B := Rol(B, 1);
    Result := Result or (B and $00000001);

    Result := Result shl 1;
    A := Rol(A, 1);
    Result := Result or (A and $00000001);
  end;
end;

function Convert(const A, B: string): string;
var
  aa, bb: LongWord;
begin
  aa := StrToInt('$' + A);
  bb := StrToInt('$' + B);
  Result := IntToHex(IntConvert(aa, bb), 16);
end;

[himitsu]

Delphi-Quellcode:

  for i := 0 to 31 do
  begin
    Result := Result shl 1;
    B := B shl 1;
    Result := Result or (B shr 31);

    Result := Result shl 1;
    A := A shl 1;
    Result := Result or (A shr 31);
  end;

:?:

[Blup]

Beide verschieben die Bits nach links, aber shl schiebt nur 0-Bits von rechts nach.

12345678 shl 4 -> 23456780
12345678 rol 4 -> 23456781

[Blup]

Wenn dann so:

Delphi-Quellcode:

 for i := 0 to 31 do
  begin
    Result := Result shl 1;
    Result := Result or (B shr 31);
    B := B shl 1;

    Result := Result shl 1;
    Result := Result or (A shr 31);
    A := A shl 1;
  end;

[himitsu]

Doch, kann ich, aber :oops:

Delphi-Quellcode:

  for i := 0 to 31 do
  begin
    Result := Result shl 1;
    Result := Result or (B shr 31);
    B := B shl 1;

    Result := Result shl 1;
    Result := Result or (A shr 31);
    A := A shl 1;
  end;

In diesem Fall wird das ja nur benutzt, um nacheinander jedes Bit auszulesen und in diesem Fall kann man einfach auf der anderen Seite auslesen, anstatt im Kreis zu schieben.

[edit]
jupp

[edit2]

Delphi-Quellcode:

  for i := 31 downto 0 do
  begin
    Result := Result shl 1;
    Result := Result or ((B shr i) and $1);

    Result := Result shl 1;
    Result := Result or ((A shr i) and $1);
  end;

Delphi-Quellcode:

  for i := 31 downto 0 do
  begin
    Result := Result shl 2;
    Result := Result or ((B shr (i-1)) and $1)  // schiebt SHR bei -1 nach links?
                     or ((A shr i) and $1);
  end;

?