Array zusammenhängen

[TomDooley]

Hallo

Ich verwende folgende Funktion um ein bestendes Array zu erweitern:

Delphi-Quellcode:

procedure TTest.FillArray(var aArray: tBestehendesArray; aValues: array of integer);
var
  TmpLen : integer;
  lp : byte;
begin
  TmpLen := Length(aArray);
  SetLength(aArray,TmpLen+Length(aValues));
  for lp:=0 to high(aValues) do
    aArray[TmpLen+lp] := aValues[lp];
end;

Gibt es dafür noch eine elegantere Möglichkeit?

[Der_Unwissende]

Hi,
es gibt auf jeden Fall eine deutlich schnellere:

Delphi-Quellcode:

procedure TTest.FillArray(var aArray: tBestehendesArray; aValues: array of integer); 
var 
  TmpLen : integer; 
  lp : byte; 
begin 
  TmpLen := Length(aArray); 
  SetLength(aArray,TmpLen+Length(aValues)); 
  copyMemory(@aArray[TmpLen], @aValues[0], sizeOf(aValues[0]) * length(aValues)); 
end;

CopyMemory ist dabei aus der Unit Windows.

Gruß Der Unwissende

[Dani]

Hi, ich denke nicht, dass eine effizientere Implementierung sehr sinnvoll wäre, da du dir für das Aneinanderhängen von Daten sowieso eine schlecht geeignete Datenstruktur ausgesucht hast. Wenn du weißt, dass in diesem Array niemals mehr als ~100 Einträge liegen, brauchst du dir auch nicht weiter Gedanken darüber zu machen. Sind es (viel) mehr Einträge, nimm eine Datenstruktur, die zu deiner Aufgabe passt (Suchen? Sortieren? Aneinanderhängen? etc)

Gruß, Dani

[shmia]

Du könntest die Daten effektiver (=schneller) mit der Move Prozedure bewegen.
Aber Achtung: wäre das Array von Typ: array of string; wäre dies verboten.
Deine Prozedure könnte so aussehen (ungetestet!!!):

Delphi-Quellcode:

procedure AppendArray(var aArray: TIntegerArray; aValues: TIntegerArray);
var 
  TmpLen : integer; 
  lp : byte; 
begin 
  TmpLen := Length(aArray); 
  SetLength(aArray,TmpLen+Length(aValues)); 
  Move(aValues[0], aArray[TmpLen], Length(aValues)*sizeof(Integer));
end;

Bei Verwendung von Move muss man höchste Vorsicht walten lassen, damit kein Speicher "zerschossen" wird.
PS: ich habe den Namen der Procedure geändert; ist so deutlich sprechender

[Ferber]

Hi !

Kleine Änderung spart Berechnung innerhalb der Schleife !

Delphi-Quellcode:

procedure TTest.FillArray(var aArray: tBestehendesArray; aValues: array of integer); 
var 
  TmpLen : integer; 
  lp : byte; 
begin 
  TmpLen := Length(aArray); 
  SetLength(aArray,TmpLen+Length(aValues)); 
  for lp:=TmpLen to TmpLen+high(aValues) do 
    aArray[lp] := aValues[lp]; 
end;

[SirThornberry]

Zitat von shmia:

Du könntest die Daten effektiver (=schneller) mit der Move Prozedure bewegen.
Aber Achtung: wäre das Array von Typ: array of string; wäre dies verboten.
Deine Prozedure könnte so aussehen (ungetestet!!!):

Delphi-Quellcode:

procedure AppendArray(var aArray: TIntegerArray; aValues: TIntegerArray);
var 
  TmpLen : integer; 
  lp : byte; 
begin 
  TmpLen := Length(aArray); 
  SetLength(aArray,TmpLen+Length(aValues)); 
  Move(aValues[0], aArray[TmpLen], Length(aValues)*sizeof(Integer));
end;

Bei Verwendung von Move muss man höchste Vorsicht walten lassen, damit kein Speicher "zerschossen" wird.
PS: ich habe den Namen der Procedure geändert; ist so deutlich sprechender

CopyMemory ruft doch auch nur Move auf. Damit hat man nur das zusätzliche Stack schaufeln wenn man anstelle von Move Copy Memory verwendet.

[TomDooley]

Danke an alle! Ich werde in dem Fall Move verwenden.

[Der_Unwissende]

Zitat von Ferber:

Kleine Änderung spart Berechnung innerhalb der Schleife !

Die Schleife an sich ist aber schon das Problem. Einerseits müssen hier wirklich mehrere Aufrufe stattfinden und andererseits wird hier jedes Datum einzeln kopiert. Das kopieren eines Datums kostet aber (unabhängig von dessen Größe) fast immer die gleiche Zeit. Kopiert man also ein Array, so werden die Kosten für das Kopieren der Elemente auf alle Elemente im Array umgelegt, der Overhead ist << als der für das Kopieren in einer Schleife.

Was die Move Prozedur angeht, so greift CopyMemory auch nur auf Move zurück, also ist Move hier noch etwas flinker.

[ADD]
Sorry, kein roter Kasten, komisch
[/ADD]