2 Arrays vergleichen\sortieren

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 von EWeiss:

markieren

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 von Fritzew:

markieren

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 von Neutral General:

Zitat von Fritzew:

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 von Fritzew:

Zitat von Neutral General:

Zitat von Fritzew:

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 von EWeiss:

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!

markieren

Code:

			PVOID Destination, Source;

SIZE_T MemorySize;

MemorySize = sizeof(short); 

Destination = &buffer[0] + (K * MemorySize);

Source = &A2[K];

MoveMemory(Destination, Source, MemorySize);

markieren

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 von 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.

Danke wollte es gerade posten......

markieren

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 von EWeiss:

markieren

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.).