Entwickler-Ecke :: Thema anzeigen - BlockRead

tommie-lie - Mo 31.03.03 21:12

Warum benutzt du da keine Streams?

Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:

var
  File1: TFileStream;
  b: Byte;
begin
  File1 := TFileStream.Create('C:\temp.tmp', fmCreate);
  b := 12;
  File1.Write(b, 1);
  File.Free;
end;

So schreibst du den Bytewert 12 in eine Datei. Da ein Byte immer ein Byte lang ist (häh... *g*) kannst du alle hintereinanderspeichern und brauchst nicht, wie bei Longstrings die Länge speichern.

Analog zum Lesen:

Quelltext

1:
2:
3:

File1.Create('C:\temp.tmp', fmOpenRead);
File1.Read(b, 1);
File1.Free;

Auch hier ist b wieder ein Byte und du kannst damit rechnen wie mit jeder anderen Variable auch.

Mehrere Zahlen lassen sich auch hintereinanderschreiben:

Quelltext

1:
2:
3:

var b1, b2: Byte;
File1.Write(b1, 1);
File1.Write(b2, 1);

Und für die grundsätzliche Frage, wie man an einen Bytewert in einem String kommt: ord():

Quelltext

1:	b := ord(mystring[1]);

Für alles weitere über Streams (sind IMHO praktischer als "normale" Fiels) empfehle ich die Lektüre der Delphi Onlinehilfe.

Delete - Mi 02.04.03 13:31

@Biarchiv: Ich glaube, du solltest dich mal in der Delphi-Hilfe mit den verschiedenen Integertypen und ihren Größen (Bereichen) befassen. Du gehst im Augenblick einen sehr umständlichen Weg.
Und bei aller Toleranz für Schreib- und Schusseligkeitsfehler: zumindest bei deinen Fragen solltest du dich um verständliche Formulierungen bemühen und sie nicht einfach so hinschludern. Ein wirklich gutes Beispiel aus deinem zweiten Posting:

Biarchiv hat folgendes geschrieben:

Grundsetzlich wie bekomme ich den Bytewert in einen String?

Ich hätte das mit chr beantwortet, denn die Frage war ja nicht:

Zitat:

Wie bekomme ich ein bestimmtes Byte (Zeichen) aus einem String?

Aber so hat möglicherweise auch tommie-lie recht ... Man weiß eben nicht genau, was du eigentlich meinst.

So, jetzt aber -

Zitat:

Oderer Mehrere Byte positionen zusammen in einen String verbinden. Pos1: 66h Pos2: 55h Pos3: 22h Pos4: 11h in String: 66552211h

Ich nehme mal an, wenn du die Datei in einem Hex-Editor ansiehst, dann sieht das so aus:

Quelltext

1:	66 55 22 11

Dann frage ich mich, warum du mit vier Bytes arbeiten willst. Wenn du 100% sicher bist, dass diese 4 Bytes zusammen eine Zahl ergeben, dann benutze einen 32-Bit-Wert (integer, cardinal, longint, longword). Um bei deinem BlockRead-Beispiel zu bleiben:

Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:

var
  lWert : longint;
begin
  { ... }

  Seek(f,lPos + 5);
  BlockRead(f,lWert,sizeof(lWert),iRead);

  { ... }

Voilà. Damit hast du die vier einzelnen Bytes auf einen Schlag gelesen, und -man höre und staune!- sie bilden sogar die Zahl, die du erst mühsam errechnen wolltest.

Dazu muss allerdings gesagt werden, dass Windows beim Speichern und Lesen von solchen Daten grundsätzlich immer das niederwertigste Byte zuerst benutzt. Das heißt, tatsächlich ist die gelesene Zahl nicht $66552211 sondern $11225566 (um bei den Hex-Werten zu bleiben).
Irgendwie habe ich jetzt ein Deja vù ... Also habe ich das wohl schon mal erwähnt. Egal. Wenn man gleich die richtigen Typen benutzt, dann muss man sich nicht um solche Sachen kümmern, weil dafür das Betriebssystem im Hintergrund zuständig ist.

Zitat:

Wie bekomme ich jetzt Byte1 - 4 in einen Byte also

Quelltext

1:	byteges := byte1 + byte2 + byte3 + byte4; // ZB.:00112233h

Dieser Ansatz wäre definitiv falsch!

Ein Byte liegt nur im Bereich von 0 bis 255. Addierst du mehrere Bytes, dann ist es durchaus möglich, dass der Maximalwert (255) überschritten wird. Deklarierst du die Ergebnisvariable nun aber auch als Byte, wird die errechnete Zahl niemals stimmen. Du musst also einen Typ wählen, der groß genug ist.
Außerdem dürfen in diesem Fall die Bytes nicht einfach so addiert werden. Denk doch nur mal an den Wert 256. Der sähe in einem Hex-Editor so aus:

Quelltext

1:	00 01 00 00

Würdest du diese vier Bytes einfach nur addieren, kämst du logischerweise auf den Wert Eins (0+1+0+0). Du musst beim "Zusammenrechnen" auch den Grundwert (mir fällt gerade der korrekte Begriff nicht ein; wer ihn weiß, bitte ergänzen!) jedes Bytes berücksichtigen, damit am Ende die gewünschte Zahl herauskommt. Richtig wäre in diesem Fall daher eine Rechnung wie

Quelltext

1:	Ergebnis := byte1 + ($100 * byte2) + ($10000 * byte3) + ($1000000 * byte4);

oder (eleganter)

Quelltext

1:	Ergebnis := byte1 + (byte2 shl 8) + (byte3 shl 16) + (byte4 shl 24)

oder (einfacher)

Quelltext

1:	Ergebnis := MAKELONG(MAKEWORD(byte1,byte2),MAKEWORD(byte3,byte4));

Zitat:

Wie kann ich dann diese 4 Bytes wieder zerlegen?

Zum Zerlegen würde ich HIWORD/LOWORD und HIBYTE/LOBYTE empfehlen. Am Beispiel:

Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:

var
  iInt : longint;
begin
  iInt := $11225566;
  //             ==---> niederwertiges Byte im niederwertigen Word
  //           ==-----> höherwertiges Byte im niederwertigen Word
  //         ==-------> niederwertiges Byte im höherwertigen Word
  //       ==---------> höherwertiges Byte im höherwertigen Word

  ShowMessage(
    inttohex(LOBYTE(LOWORD(iInt)),2) + #32 +  // = $66
    inttohex(HIBYTE(LOWORD(iInt)),2) + #32 +  // = $55
    inttohex(LOBYTE(HIWORD(iInt)),2) + #32 +  // = $22
    inttohex(HIBYTE(HIWORD(iInt)),2)    // = $11
  );
end;

Gruß.

Entwickler-Ecke.de based on phpBB
Copyright 2002 - 2011 by Tino Teuber, Copyright 2011 - 2026 by Christian Stelzmann Alle Rechte vorbehalten.
Alle Beiträge stammen von dritten Personen und dürfen geltendes Recht nicht verletzen.
Entwickler-Ecke und die zugehörigen Webseiten distanzieren sich ausdrücklich von Fremdinhalten jeglicher Art!