Array[0..x] of Byte in Array of Byte kopieren

[Kostas]

Hallo zusammen,

Move sollte doch in der Lage sein ein statisches Array in ein dynamisches Array zu kopieren oder etwa nicht?
Natürlich muss ich auf die Grenzen achten. Alternativ, ich kopiere Byte für Byte in einer Schleife.

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
const
    cHeaderZumTest: array [0..13] of byte = ($42,
                                             $22,
                                             $1, $43, $72, $71,
                                             $29, $D1, $84,
                                             $0, $41,
                                             $0, $1F, $CC);

var DFProtokoll:TDFProtokoll;
    DataPaketArray:TDataPaketArray;  //type TDataPaketArray = Array of Byte;
begin
  SetLength(DataPaketArray,SizeOf(cHeaderZumTest));

  Move(cHeaderZumTest, DataPaketArray, SizeOf(DataPaketArray));  <<DataPaketArray hat nun 131000 leere Elemente
  DFProtokoll := TDFProtokoll.Create(DataPaketArray); //Der constructor erwarten ein TDataPaketArray

end;

Gruß Kostas

[Medium]

Probier mal "Move(cHeaderZumTest[0], DataPaketArray[0], SizeOf(DataPaketArray));". Ich bin bei Move() immer etwas unsicher welche Compilermagic es alles nun bedenkt, aber an sich nimmt es Pointer auf die Variablen in den Parametern. Wenn man direkt auf's erste Element referenziert dürfte es eindeutig sein.
Edit: Das SizeOf() macht mir hier auch etwas Kopfweh, auch wenn es bei Arrays fixer Länge so funktioniert. Ganz sauber wäre die Formel "Length(MyArray)*SizeOf(MyArray[0])" für Längenangaben in Byte, und das klappt dann auch mit dynamischen Arrays.

[Kostas]

Perfekt, so funkt es einwandfrei. Zusätzlich habe ich umgestellt auf Length.
Tausend Dank dafür.

Dir noch eine schöne Zeit.
Gruß Kostas

[himitsu]

Nur um den Grund nochmal zu nennen.

Mit xxx[0] referenziert man immer das erste Element eines Arrays (wenn das bei 0 beginnt).

Ein dynamisches Array ist aber ein Zeiger, auf seinen Array-Inhalt, (wie ein TObject, bzw. wie ein Zeiger auf ein statisches Array)
während ein statisches Array selber der Array-Inhalt ist (wie ein Record).

Du müsstest also erst das dynamische Array dereferenzieren, danach hätte dein Code funktioniert.
- also entweder immer über das jeweils erste Feld (auch wenn man es beim statischen Array weglassen könnte, aber besser immer überall gleich behandeln, so macht man es nicht mal ausversehn falsch)
- oder eben auf andere Weisen den Zeiger des Dynamischen auflösen, bzw. wenn man statt Move z.B. MoveMemory verwendet, dann alternativ beim statischen Array den Pointer erzeugen.

Und SizeOf der Variable des dynamischen Arrays liefert natürlich immer nur die Größe des Zeigers (4 Byte).
Hier mußt diu also entweder den die Größe des Feld-Typs mit der Anzahl multiplizeren (SizeOf(Byte)*Length(arr) ) oder eben die Größe eines Feldes (am Einfachsten des Ersten) mit der Anzahl multiplizieren (SizeOf(arr[0])*Length(arr) ).
Beim statischen Array kann man die Größe grundsätzlich genauso bestimmen, aber da kann man auch einfach SizeOf(arr) nehmen, weil dort ja kein Pointer dazwischen liegt.



Grundsätzlich:
Sobald man mit Pointern oder so potentiell gefährlichen Funktionen ala Move rumhantiert, muß man unbedingt zuerst lernen wie die Typen intern aufgebaut sind.
z.B. ein array of string oder ein array of Record mit Strings drin, kann/darf man so nicht umkopieren.
PS: Drum muß man z.B. im .NET auch erstmal explizit den Zugriff freischalten, bevor man sowas Böses machen darf.

[Kostas]

Danke für die sehr ausführliche Antwort.

Ich habe mich schon gefragt warum dass denn? jetzt verstehe auch ich das.

Tausend Dank, und eine schöne Zeit.

Gruß Kostas