2 Arrays vergleichen\sortieren

[EWeiss]

Ok das Problem hat sich erledigt.. SortShortTagArray aber noch nicht.
Wer vergleichen will.

Delphi-Quellcode:

function TSkinSpriteContainer.GetObjectOrder(hParent: HWND): Integer;
var
  gP, UB: Integer;
  K, Count: Integer;
  A1, A2: TArray<short>;
  // nur noch 512 Einträge zur Verfügung muss sehen ob ich das Array nicht wieder erhöhe.
  // 512 Objekte auf einer Form sind schnell erreicht.
  buffer: array [0 .. 1023] of Short;
begin

  gP := gPropertyItem(hParent);
  if (gP > -1) then
  begin
    if (g_Prop[gP].ordersize <> 0) then
    begin
      result := gP;
      exit;
    end;
  end;

  UB := High(g_Obj);
  if (UB > 0) then // müsste eigentlich "-1" sein weil das Array in Delphi bei 0 anfängt. (Muss vorher noch prüfen welche Auswirkungen das hat)
  begin
    Count := 0; // hier eigentlich das gleiche -1
    SetLength(A1, UB + 1);
    SetLength(A2, UB + 1);

    for K := 0 to UB do // ist der höchste Array Index deshalb kein "UB - 1"
    begin
      if (g_Obj[K].Handle = hParent) then
      begin
        A1[Count] := (g_Obj[K].order);
        A2[Count] := (K);
        inc(Count);
      end;
    end;
    //ARRAY SORT A1() FOR Count, TAGARRAY A2();
    //SortShortTagArray (A1, A2, nCount); noch nicht fertig

    FillChar(buffer, sizeof(buffer), 0);
    for K := 0 to Count do
      MoveMemory(PByte(@buffer[0]) + K * sizeof(Short), @A2[K], sizeof(Short));

    FillChar(A1, sizeof(A1), 0);
    FillChar(A2, sizeof(A2), 0);

    if (gP < 0) then
    begin
      gP := High(g_Prop) + 1;
      SetLength(g_Prop, gP + 1);
    end;

    g_Prop[gP].Handle := hParent;
    MoveMemory(@g_Prop[gP].Order, @buffer[0], sizeof(buffer));
    g_Prop[gP].Ordersize := Count - 1; // Array beginnt bei 0 alternativ kann ich Count direkt -1 zuweisen
   end;
   Result := gP;
end;

gruss

[Fritzew]

Hall Emil,
nur mal was ich auf die schnell gesehen habe

Zitat:

Zitat von EWeiss (Beitrag 1387031)

Delphi-Quellcode:

  FillChar(buffer, sizeof(buffer), 0);
    for K := 0 to Count do  // Warum nicht Count-1? Wenn z.B Count 1 ist kopierst Du 2 Einträge?
 //     MoveMemory(PByte(@buffer[0]) + K * sizeof(Short), @A2[K], sizeof(Short));
  buffer[K] := A2[K];   // Warum das Pointer geschubse? Einfach zuweisen was anderes macht der C Code auch nicht

   // FillChar(A1, sizeof(A1), 0);
   // FillChar(A2, sizeof(A2), 0);
  A1 := nil; // Das Fillchar kannst Du dir sparen einfach den Speicher freigeben
 A2 := nil;

[Neutral General]

Zitat:

Zitat von Fritzew (Beitrag 1387041)

Delphi-Quellcode:

  A1 := nil; // Das Fillchar kannst Du dir sparen einfach den Speicher freigeben
  A2 := nil;

Das auf nil setzen kannst du dir auch sparen ;) Das gibt keinen Speicher frei, sondern setzt nur 2 Variablen auf nil.
Der Speicher für das Array wird am Ende der Methode automatisch freigegeben.

[Fritzew]

Zitat:

Zitat von Neutral General (Beitrag 1387047)

Zitat:

Zitat von Fritzew (Beitrag 1387041)

Das auf nil setzen kannst du dir auch sparen ;) Das gibt keinen Speicher frei, sondern setzt nur 2 Variablen auf nil.
Der Speicher für das Array wird am Ende der Methode automatisch freigegeben.

Alte Angewohnheit, wenn ich Speicher hole gebe ich Ihn auch frei ;-)
liest sich für mich immer flüssiger.....

[Neutral General]

Zitat:

Zitat von Fritzew (Beitrag 1387050)

Zitat:

Zitat von Neutral General (Beitrag 1387047)

Zitat:

Zitat von Fritzew (Beitrag 1387041)

Das auf nil setzen kannst du dir auch sparen ;) Das gibt keinen Speicher frei, sondern setzt nur 2 Variablen auf nil.
Der Speicher für das Array wird am Ende der Methode automatisch freigegeben.

Alte Angewohnheit, wenn ich Speicher hole gebe ich Ihn auch frei ;-)
liest sich für mich immer flüssiger.....

Etwas auf nil zu setzen gibt aber nichts frei ;) (Außer vllt. durch die gleiche Compiler-Magic die das Array am Ende sowieso automatisch freigibt).
Wenn du wirklich aktiv Speicher freigeben willst, dann benutz zumindest SetLength(array, 0);

[DeddyH]

Kleiner Einspruch: es handelt sich ja um ein dynamisches Array, und da gilt (http://docwiki.embarcadero.com/RADSt...amische_Arrays)

Zitat:

Dynamische Array-Variablen sind implizit Zeiger und werden mit derselben Referenzzählung verwaltet wie lange Strings. Um ein dynamisches Array freizugeben, weisen Sie einer Variable, die das Array referenziert, den Wert nil zu, oder Sie übergeben die Variable an Finalize. Beide Methoden geben das Array unter der Voraussetzung frei, dass keine weiteren Referenzen darauf vorhanden sind. Dynamische Arrays werden immer freigegeben, sobald ihr Referenzzähler null ist.

[TiGü]

Zitat:

Zitat von EWeiss (Beitrag 1387030)

Zum Thema mich hat das nur mit dem MoveMemory geärgert das man hier hunderte von Konvertierungen machen muss
um am ende das gleiche Ergebnis zu bekommen wie unter den anderen Sprachen auch.

Wenn du dir das Leben einfacher machen würdest, dann hättest du auch nicht solche Probleme.
Nicht immer alles in einer Zeile Lösen wollen, das führt zu nix.
Das ist schwer lesbar und macht es kompliziert.
Komplizierte Dinge führen zu Fehlern, das regt dich auf.
Wenn du dich aufregst, wirst du unsachlich.
Wenn du unsachlich wirst, suchst du den Fehler bei dem Computer, dem Compiler, dem verwendeten Framework, der WinApi, der Sprache und/oder den Leuten, die dir nur helfen wollen und dabei auch mal ihre Worte nicht in Zuckerwatte packen.
Ist ja auch kein Streichelzoo hier!

Code:

PVOID Destination, Source;
SIZE_T MemorySize;

MemorySize = sizeof(short); 
Destination = &buffer[0] + (K * MemorySize);
Source = &A2[K];
 
MoveMemory(Destination, Source, MemorySize);

Delphi-Quellcode:

var
 Destination, Source: Pointer;
 MemorySize: SIZE_T; 
begin
...
  MemorySize := SizeOf(Short);
  Destination := Pointer(NativeUInt(@buffer[0]) + K * MemorySize);  
  Source := @A2[K];  
  MoveMemory(Destination, Source, MemorySize);

[Fritzew]

Zitat:

Zitat von DeddyH (Beitrag 1387054)

Kleiner Einspruch: es handelt sich ja um ein dynamisches Array, und da gilt (http://docwiki.embarcadero.com/RADSt...amische_Arrays)

Zitat:

Dynamische Array-Variablen sind implizit Zeiger und werden mit derselben Referenzzählung verwaltet wie lange Strings. Um ein dynamisches Array freizugeben, weisen Sie einer Variable, die das Array referenziert, den Wert nil zu, oder Sie übergeben die Variable an Finalize. Beide Methoden geben das Array unter der Voraussetzung frei, dass keine weiteren Referenzen darauf vorhanden sind. Dynamische Arrays werden immer freigegeben, sobald ihr Referenzzähler null ist.

Danke wollte es gerade posten......

[EWeiss]

Delphi-Quellcode:

var
  Destination, Source: Pointer;
  MemorySize: SIZE_T; 
begin
 ...
   MemorySize := SizeOf(Short);
   Destination := Pointer(NativeUInt(@buffer[0]) + K * MemorySize); 
   Source := @A2[K]; 
   MoveMemory(Destination, Source, MemorySize);

Das ist keine schlechte Erklärung bzw. zu zeigen wie MoveMemory Arbeitet.
Aber sorry hier eine Funktion in 20 teile zu zerlegen macht nicht wirklich sinn.
Hilfsvariablen und Funktionen einzurichten mach sinn bei immer widerkehrenden Mechanismen aber nicht bei einer Zeile Code.
Habe noch nirgends gesehen das jemand CopyMemory in 100 Zeilen zerlegt.

gruss

[TiGü]

Zitat:

Zitat von EWeiss (Beitrag 1387082)

Delphi-Quellcode:

var
  Destination, Source: Pointer;
  MemorySize: SIZE_T; 
begin
 ...
   MemorySize := SizeOf(Short);
   Destination := Pointer(NativeUInt(@buffer[0]) + K * MemorySize); 
   Source := @A2[K]; 
   MoveMemory(Destination, Source, MemorySize);

Das ist keine schlechte Erklärung bzw. zu zeigen wie MoveMemory Arbeitet.
Aber sorry hier eine Funktion in 20 teile zu zerlegen macht nicht wirklich sinn.
Hilfsvariablen und Funktionen einzurichten mach sinn bei immer widerkehrenden Mechanismen aber nicht bei einer Zeile Code.
Habe noch nirgends gesehen das jemand CopyMemory in 100 Zeilen zerlegt.

Aus einer unübersichtlichen Zeile werden vier. Nur drei, wenn man sich das spart die MemorySize hinzuschreiben. Plus halt die übliche Variablendeklaration.

Das ist kaum Overhead, ist besser lesbar und vor allen besser debugbar.

Wenn du es gleich so hingeschrieben hättest, dann hättest du auch sofort verstanden wo dein Problem liegt.
So haste erstmal ewig rumgeflucht und gedacht das Delphi sich hier anderes als C++ verhält bei einer WinApi-Funktion.
Das dem nicht so ist, siehste ja jetzt.

Die Leute, die solche Sachen nicht in "100 Zeilen" (danke für die schlechte Polemik) zerteilen (müssen), wissen in der Regel aber auch was sie tun.
Du bist - wie du selber betonst - halt Laie und manche Feinheiten sind dir fremd oder unverständlich (C++-Char -> Delphi-Byte, Größen von Datentypen, Operator-Überladung, Zeigerarithmetik...etc.).