Suche String->Hex Funktion

[Jumpy]

Hallo,
suche eine Funktion, die mir einen (wahrsch. Ascii-)String Zeichen für Zeichen in die Entsprechende Hex-Darstellung umwandelt. Gibt es da in Delphi (2010) etwas? StrToHex oder so scheint die Hilfe nicht zu finden.

Mir würde es natürlich schon reichen, wenn es eine Funktion gibt, die einfach nur ein Zeichen in Hex umwandelt, analog wie es z.B. CHR() macht. Über den String iterieren kann ich dann zur Not noch selber.

Möchte halt ungern so eine Funktion selber schreiben, die ja nix anderes macht als die "Übersetzung" des Zeichens in einer Liste nachzugucken oder die aus 256 If-Elsen besteht, wenn es sowas doch bestimmt schon gibt.

[mkinzler]

StrToBin()

[DeddyH]

Meinst Du so etwas?

Delphi-Quellcode:

Format('%.2x', [Ord('A')])

[Bernhard Geyer]

Zitat:

Zitat von DeddyH (Beitrag 1155007)

Meinst Du so etwas?

Delphi-Quellcode:

Format('%.2x', [Ord('A')])

Wenn schon dann %.4x - Unser String ist ja schon seit 4 Versionen standardmäßig Unicode-Fähig :-)

[Jumpy]

Danke Deddyh. Mit der Format-Funktion hat das geklappt. Muss zwar nochmal alle exotischen Zeichen ausprobieren, aber es sieht gut aus:

Delphi-Quellcode:

procedure TForm2.Button2Click(Sender: TObject);
begin
  showmessage(Hex(edCommand.Text));
end;

function TForm2.Hex(s: String): String;
var
  h:String;
  i:integer;
begin
  for i := 1 to Length(s) do
    h:=h+Format('%.2x', [Ord(s[i])]);
  Result:=h;
end;

StrToBin() kannte mein Delphi auch nicht :(

[DeddyH]

Zitat:

Zitat von Bernhard Geyer (Beitrag 1155009)

Zitat:

Zitat von DeddyH (Beitrag 1155007)

Meinst Du so etwas?

Delphi-Quellcode:

Format('%.2x', [Ord('A')])

Wenn schon dann %.4x - Unser String ist ja schon seit 4 Versionen standardmäßig Unicode-Fähig :-)

So besser?

Delphi-Quellcode:

function StrToHex(const s: string): string;
var
  CharWidth, i: integer;
  FormatStr: string;
begin
  CharWidth := SizeOf(Char) * 2;
  FormatStr := Format('%%.%dx', [CharWidth]);
  for i := 1 to Length(s) do
    Result := Result + Format(FormatStr, [Ord(s[i])]);
end;

[himitsu]

Zitat:

Zitat von mkinzler (Beitrag 1155006)

StrToBin()

Nicht StrToHex BinToHex?

[edit]

Zitat:

StrToBin() kannte mein Delphi auch nicht

In der OH steht bei dir auch nichts dazu? (nicht daß nicht nur die Unit fehlte)

In den INDY sind auch Klassen dafür enthalten, falls die bei dir installiert sind.

[Jumpy]

Die erste Variante mit .2 war schon OK. Ausgangspunkt wird ja wahrsch. ein Ansi-String sein. Daher kann die Gegenseite, der das als Command später geschickt wird, mit "2B3439..." wahrscheinlich mehr anfangen als mit "002B00340039...".

Kleines Rätsel für Gelangweilte: Was wird da wohl verschickt werden?

Und nochmal danke für die Beteiligung.

[Neutral General]

IntToHex gibt es um eure Verwirrung mal aufzuheben ;-)

[shmia]

Siehe Code-Library: http://www.delphipraxis.net/39740-he...aerstring.html
Diese Funktionen sind viel schneller als das Zeichenweise anhängen wie im Beispiel oben.

[Sir Rufo]

@DeddyH

Warum so umständlich?

Delphi-Quellcode:

function StrToHex( const s: string ): string;
var
  i : integer;
begin
  for i := 1 to Length( s ) do
    Result := Result + Format( '%.*x', [SizeOf( Char ) * 2, Ord( s[i] )] );
end;

[Coffeecoder]

Zitat:

Zitat von Sir Rufo (Beitrag 1155061)

@DeddyH

Warum so umständlich?

Delphi-Quellcode:

function StrToHex( const s: string ): string;
var
  i : integer;
begin
  Result := ''; // <----
  for i := 1 to Length( s ) do
    Result := Result + Format( '%.*x', [SizeOf( Char ) * 2, Ord( s[i] )] );
end;

Muss nicht noch vorher Result initialisiert werden?

[DeddyH]

Bei Strings nicht, aber Du darfst das natürlich tun.

[Coffeecoder]

Zitat:

Zitat von DeddyH (Beitrag 1155068)

Bei Strings nicht, aber Du darfst das natürlich tun.

Gut dann packe ich einige Funktionen aus, wo ich das immer gemacht habe ;)

[DeddyH]

Lass es doch drin, und wenn es nur dem besseren Verständnis dient ;)

[himitsu]

Zu 99% geht es auch ohne Initialisierung, aber darauf verlaß dich besser mal nicht. :roll:

Das Result ist leider ein ganz blöder Sonderfall, denn die automatisch Initialisierung von String, dyn. Array und Interface liegt nicht in der Methode, so wie bei den lokalen Variablen, sondern beim Aufrufer und da gibt es ganz nette Seiteneffekte, welche dafür sorgen, daß das Result nicht mit '' vorbelegt sein könnte.

[gammatester]

99% scheint mir eine mutige Schätzung, gerade für Delphi 6, denn

Delphi-Quellcode:

function dummy: string;
begin
  result := result + ' oder so';
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  s: string;
begin
  s := '42';
  s := dummy;
  showmessage(s);
end;

zeigt zB zuverlässig '42 oder so' an. Und im Assembler ist nix zu sehen vom Vorherlöschen.

[himitsu]

OK, dann maximal 50%?

Mir war das bisher nur in Schleifen aufgefallen.


Aber das Fazit ist ganz einfach.
Result-Variablen müssen/sollten immer initialisiert werden, wenn mit ihnen gerechnet wird.
Also immer dann, wenn das Result, innerhalb der Funktion, ausgewertet und nicht nur stur gesetzt wird.

Mam muß bedenken, daß bei diesen gemanagten Result-Typen vom Compiler eine Prozedur daraus gemacht wird.
Aus

Delphi-Quellcode:

function dummy(i: Integer): string;

wird

Delphi-Quellcode:

procedure dummy(i: Integer; var Result: string);

, was man im Assembler gut erkennen kann.

[p80286]

Zitat:

Zitat von shmia (Beitrag 1155051)

Siehe Code-Library: http://www.delphipraxis.net/39740-he...aerstring.html
Diese Funktionen sind viel schneller als das Zeichenweise anhängen wie im Beispiel oben.

Aber obacht, D2010 hat als Standard 16Bit Chars und da könnte es Probleme geben.
(sizeof statt length nutzen?)

Gruß
K-H

[DeddyH]

Besser beides: Length * SizeOf(Char)
Nee, Quatsch, es sind ja beides Strings.

[Sir Rufo]

Zitat:

Zitat von p80286 (Beitrag 1155113)

Zitat:

Zitat von shmia (Beitrag 1155051)

Siehe Code-Library: http://www.delphipraxis.net/39740-he...aerstring.html
Diese Funktionen sind viel schneller als das Zeichenweise anhängen wie im Beispiel oben.

Aber obacht, D2010 hat als Standard 16Bit Chars und da könnte es Probleme geben.
(sizeof statt length nutzen?)

Gruß
K-H

Du meinst eher

Delphi-Quellcode:

Length( s ) * SizeOf( s[1] ) * 2

[p80286]

Wenn ich ehrlich bin ist mir diese "Length(x)*sizeof(x[1])" etwas suspect.
Da bei der Umwandlung irgendwas_Hex immer ein Byte in 2Zeichen umgewandelt wird sollte byteweise gelesen werden und mit char geschrieben werden, also ungefähr so

setlength(dest,sizeof(source)*2);
for i:=1 to sizeof(source) do
dest[i]:=machwas(source[i]);

Gruß
K-H

[DeddyH]

Lass Dir mal SizeOf(string) ausgeben.

[edit] Schon selbst gemacht:

Delphi-Quellcode:

var
  s: string;
begin
  s := 'Hallo Welt';
  ShowMessage(Format('%d - %d - %d', [SizeOf(s), Length(s), Length(s) * SizeOf(Char)]));
end;

Ergibt unter XE 4 - 10 - 20, unter Delphi 2007 4 - 10 - 10 [/edit]

[p80286]

Zitat:

Zitat von DeddyH (Beitrag 1155135)

Lass Dir mal SizeOf(string) ausgeben.

Delphi-Quellcode:

type
 mystr : string[255];

sizeof(mystr) liefert 256 !

Wenn ich mich richtig erinnere gab es bei Ansi Strings da auch eine Möglichkeit.
und um die 16Bitter kümmer ich mich wenn's notwendig wird.

Aber ist schon recht, man muß wissen was man da anstellt, und nicht ungeprüft übernehmen was man irgendwo liest.

Gruß
K-H

[DeddyH]

ShortStrings und Strings (also AnsiString oder UnicodeString, je nach Version) sind ja 2 vollkommen verschiedene Paar Schuhe.

[Bummi]

ich vermute es war folgendes gemeint

Delphi-Quellcode:

var
 s:String;
begin
 s := 'Nasenbär';
 Showmessage(IntToStr(SizeOf(s)));
end;

[DeddyH]

Japp, siehe mein Edit in #23.

[himitsu]

Delphi-Quellcode:

var
  S: String;

Label1.Caption := Format('%s %s', [SizeOf(Char), SizeOf(S[1]), StringElementSize(S)]);

:stupid:

[Bummi]

'%d %d %d'

[DeddyH]

Und mein Delphi 2007 kennt kein StringElementSize.

[himitsu]

StringElementSize wurde eingeführt, als in D2009 der UnicodeString eingeführt und der AnsiString verändert/erweitert wurde.

Delphi-Quellcode:

function StringElementSize(const S: String): Word; // String = AnsiString, UnicodeString oder WideString
function StringCodePage(const S: String): Word; 
function StringRefCount(const S: String): Integer; 

procedure SetCodePage(var S: RawByteString; CodePage: Word; Convert: Boolean = True);

procedure SetAnsiString(Dest: PAnsiString; Source: PWideChar; Length: Integer; CodePage: Word);

procedure SetMultiByteConversionCodePage(CodePage: Integer);  // ändert die Standardcodepage für einfache AnsiStrings

function UnicodeFromLocaleChars(CodePage, Flags: Cardinal; LocaleStr: PAnsiChar;
  LocaleStrLen: Integer; UnicodeStr: PWideChar; UnicodeStrLen: Integer): Integer; overload;
function LocaleCharsFromUnicode(CodePage, Flags: Cardinal;
  UnicodeStr: PWideChar; UnicodeStrLen: Integer; LocaleStr: PAnsiChar;
  LocaleStrLen: Integer; DefaultChar: PAnsiChar; UsedDefaultChar: PLongBool): Integer; overload;