2 Arrays vergleichen\sortieren

[EWeiss]

Zitat:

Sollte in etwa so aussehen. Ist nur so runtergetippt, also kann noch Fehler enthalten:

Werde es mal testen.
------
Funktioniert leider nicht.. Danke.

langsam nervt Delphi nur noch
Ein einfaches MoveMemory oder auch CopyMemory ist das gleiche!

Delphi-Quellcode:

    
for K := 0 to g_Prop[gP].Ordersize do
begin
  MoveMemory(@Item, g_Prop[gP].order + K * sizeof(short), sizeof(short));

funktioniert nicht einmal.
Das Item sollte eigentlich inkrementieren tut es aber nicht.

Das will der Compiler auch nicht.
Ich verwende hier FillChar anstelle von FillMemory auch hier das gleiche spielt also keine rolle was ich verwende
um den Speicher mit nullen zu füllen.

Delphi-Quellcode:

buffer: array [0 .. 2047] of Char;
....
FillChar(buffer, sizeof(buffer), 0);
for K := 0 to Count do
  MoveMemory(@buffer[0] + K * sizeof(Short), @A2[K], sizeof(Short));

Zitat:

[DCC Fehler] uSpriteContainer.pas(2656): E2015 Operator ist auf diesen Operandentyp nicht anwendbar
@buffer[0] + K * sizeof(Short)

Das sind doch ganz einfache primitive API calls.
Und müssten eigentlich überall gleich funktionieren.

Ein char bleibt ein char egal ob in c++ oder Delphi, ein Array bleibt ein Array.
Warum macht der Compiler unter Delphi so einen Aufstand.

Und ja short ist SmallInt spielt also keine rolle ob ich es direkt eingebe oder short verwende.
Daran dürfte es nicht scheitern.

Zitat:

SHORT = Smallint;
{$EXTERNALSYM SHORT}

gruss

[Zacherl]

Zitat:

Zitat von EWeiss (Beitrag 1386912)

Delphi-Quellcode:

MoveMemory(@buffer[0] + K * sizeof(Short), @A2[K], sizeof(Short));

Zitat:

[DCC Fehler] uSpriteContainer.pas(2656): E2015 Operator ist auf diesen Operandentyp nicht anwendbar
@buffer[0] + K * sizeof(Short)

Dort versuchst du auch einen Pointer und einen Integer zu addieren. Probier mal

Delphi-Quellcode:

PByte(@buffer[0]) + K * sizeof(Short)

. Wenn das nicht geht, dann

Delphi-Quellcode:

Pointer(NativeUInt(@buffer[0]) + K * sizeof(Short))

.

[EWeiss]

Zitat:

Dort versuchst du auch einen Pointer und einen Integer zu addieren.

Das ist richtig was du sagst.

Nur..
Das tue ich auch unter c++ da gibt es keine Probleme bei der gleichen Übergabe.
Letztendlich verwenden beide sprachen die gleiche API darauf wollte ich hinaus. :)
Um so mehr ich mit C++ Arbeite um so mehr stelle ich fest wie verkorkst die Sprache Delphi(Compiler) eigentlich ist.

Was ist an MoveMemory in Delphi anders als in C++ eigentlich nichts.

Delphi-Quellcode:

MoveMemory(Pointer(NativeUInt(@buffer[0])) + K * sizeof(Short), @A2[K], sizeof(Short));

Das gleiche Problem.

Delphi-Quellcode:

MoveMemory(PByte(@buffer[0]) + K * sizeof(Short), @A2[K], sizeof(Short));

Lässt sich kompilieren aber ob es richtig ist bzw.. die Daten korrekt verarbeitet werden ist mir nicht ersichtlich.

Damit steht bzw. fällt das Projekt.

Delphi-Quellcode:

procedure TSkinSpriteContainer.gDrawZorderObjects(WinHandle: HWND; hDCdest: HDC;
  InPrintMode: Integer);
var
  K, Item, gP: Integer;
begin

  Item := 0;

  // Draw objects with respect of the z-order
  gP := GetObjectOrder(WinHandle);
  if (gP > -1) then
  begin
    for K := 0 to g_Prop[gP].Ordersize do
    begin
      MoveMemory(@Item, g_Prop[gP].order + K * sizeof(short), sizeof(short)); // Das Item hier müsste inkrementiert werden geht aber nicht.
      // Draw only visible objects
      if (g_Obj[Item].Visible) then
        GI_DrawObject(hDCdest, g_Obj[Item], InPrintMode);
    end;
  end;
end;

gruss

[Neutral General]

Zitat:

Zitat von EWeiss (Beitrag 1386985)

Um so mehr ich mit C++ Arbeite um so mehr stelle ich fest wie verkorkst die Sprache Delphi(Compiler) eigentlich ist.

:lol: :lol: :lol:

Du vergleichst C++ und Delphi und nennst Delphi verkorkst? :mrgreen:
Delphi ist typsicher und das einzige was du brauchst ist ein Cast. Also kein großer Akt.

Das Problem ist dass du manche Dinge eben nicht 1:1 übersetzen kannst und du übersetzt halt 1:1 und wunderst dich über Probleme ;)
Du fährst besser wenn du versuchst den Code zu verstehen und den Kram sinngemäß in Delphi implementierst.
So wie ich das sehe ist der C++ Code da nämlich DEUTLICH einfacher und kürzer in Delphi implementierbar.

[Uwe Raabe]

Zitat:

Zitat von EWeiss (Beitrag 1386985)

Um so mehr ich mit C++ Arbeite um so mehr stelle ich fest wie verkorkst die Sprache Delphi(Compiler) eigentlich ist.

Komisch, bei mir verfestigt sich genau der umgekehrte Eindruck. Man sollte seine Sprache halt passend zu seiner Denkweise aussuchen. Sieht man sich mal deine Threads der vergangenen Monate an, manifestiert sich bei mir die Vermutung, daß Du und Delphi einfach nicht füreinander geschaffen seid.

[EWeiss]

Zitat:

daß Du und Delphi einfach nicht füreinander geschaffen seid.

Jetzt keinen erneuten Hype um Delphi hier sachlich bleiben.

Zitat:

Das Problem ist dass du manche Dinge eben nicht 1:1 übersetzen kannst

Fakt ist das MoveMemory eine einfache Win32 API ist und von allen Sprachen gleich interpretiert werden sollte.
Also warum funktioniert es unter C++ und nicht mit Delphi.

Bitte Sachlicher Hinweis und keine persönlichen Angriffe Herr Uwe Rabe. (Ich weis sie lieben Delphi)
PS: Für mich ist es ein Werkzeug nichts anderes.

Zitat:

So wie ich das sehe ist der C++ Code da nämlich DEUTLICH einfacher und kürzer in Delphi implementierbar.

DEUTLICH und einfach?
Sorry ich sehe nicht das du dich mal daran versucht hättest.. Papier ist geduldig.

gruss

[Neutral General]

Zitat:

Zitat von EWeiss (Beitrag 1386991)

Also warum funktioniert es unter C++ und nicht mit Delphi.

Es funktioniert bei beiden. Delphi Syntax ist anders und in Delphi ist (standardmäßig) Pointerarithmetik nicht erlaubt weswegen du die Berechnung der Adresse als Integer machen musst und das Ergebnis dann auf Pointer castest.
MoveMemory ist wie gesagt eine Windows API und die KANN in Delphi nicht anders funktionieren als in C++.

Code:

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

=

Delphi-Quellcode:

MoveMemory(Pointer(NativeUInt(@buffer[0]) + K * sizeof(Short)), @A2[K], sizeof(Short));

Edit: Soviel zu meinem Punkt "Der C++ Code ist unnötig kompliziert" (zumindest auf Delphi übertragen):

Delphi-Quellcode:

MoveMemory(@buffer[K * sizeof(Short)], @A2[K], sizeof(Short));

geht auch.

Es hilft halt, wenn man den Code den man überträgt auch versteht ;)

[Zacherl]

Zitat:

Zitat von EWeiss (Beitrag 1386985)

Delphi-Quellcode:

MoveMemory(Pointer(NativeUInt(@buffer[0])) + K * sizeof(Short), @A2[K], sizeof(Short));

Das gleiche Problem.

Da ist dir allerdings auch eine Klammer verrutscht. Pointer() darfst du erst schließen, nachdem du fertig addiert hast.

Zitat:

Zitat von EWeiss (Beitrag 1386985)

Delphi-Quellcode:

MoveMemory(PByte(@buffer[0]) + K * sizeof(Short), @A2[K], sizeof(Short));

Lässt sich kompilieren aber ob es richtig ist bzw.. die Daten korrekt verarbeitet werden ist mir nicht ersichtlich.

Sollte passen; ist zumindest die empfohlene Vorgenehsweise für genau solche Dinge.

Zitat:

Zitat von EWeiss (Beitrag 1386985)

Delphi-Quellcode:

procedure TSkinSpriteContainer.gDrawZorderObjects(WinHandle: HWND; hDCdest: HDC;
  InPrintMode: Integer);
var
  K, Item, gP: Integer;
begin
  Item := 0;
  ...
  MoveMemory(@Item, g_Prop[gP].order + K * sizeof(short), sizeof(short)); // Das Item hier müsste inkrementiert werden geht aber nicht.
  ...
end;

Nicht, wenn an

Delphi-Quellcode:

g_Prop[gP].order + K * sizeof(short)

eine 0 (bzw. 2 Nullen) im Speicher steht.

Zitat:

Zitat von EWeiss (Beitrag 1386991)

Fakt ist das MoveMemory eine einfache Win32 API ist und von allen Sprachen gleich interpretiert werden sollte.
Also warum funktioniert es unter C++ und nicht mit Delphi.

Dein konkretes Problem ist ja unabhängig von der API. Die Funktion macht unter beiden Sprachen das Gleiche; der Unterschied liegt im Aufruf. Hier unterscheiden sich die Sprachen wie gesagt in der unterschiedlichen Zeigerarithmetik. Was man hier präferiert ist ein Stück weit Geschmackssache. C/C++ ist hier eher implizit (und auch um einiges komplizierter) und bei Delphi musst du explizit casten.

Zitat:

Zitat von Neutral General (Beitrag 1386993)

Delphi-Quellcode:

MoveMemory(@buffer[K * sizeof(Short)], @A2[K], sizeof(Short));

geht auch.

Dann aber bitte ohne das

Delphi-Quellcode:

SizeOf(Short)

im Index :P

[EWeiss]

Zitat:

Da ist dir allerdings auch eine Klammer verrutscht. Pointer() darfst du erst schließen, nachdem du fertig addiert hast.

Danke habe ich so eben bemerkt. ;)

Zitat:

Sollte passen; ist zumindest die empfohlene Vorgenehsweise für genau solche Dinge.

OK.. Werde es so übernehmen. (Auch wenn ich noch keinen sichtbaren Erfolg sehe denke da ist an anderer stelle noch ein kleines Problem.

Zitat:

Nicht, wenn an g_Prop[gP].order + K * sizeof(short) eine 0 (bzw. 2 Nullen) im Speicher steht.

Werde ich nochmals gegen prüfen.

Zitat:

Dein konkretes Problem ist ja unabhängig von der API. Die Funktion macht unter beiden Sprachen das Gleiche; der Unterschied liegt im Aufruf. Hier unterscheiden sich die Sprachen wie gesagt in der unterschiedlichen Zeigerarithmetik. Was man hier präferiert ist ein Stück weit Geschmackssache. C/C++ ist hier eher implizit (und auch um einiges komplizierter) und bei Delphi musst du explizit casten.

Ok .. Danke für die Informationen.

Zitat:

Es hilft halt, wenn man den Code den man überträgt auch versteht

Du hast natürlich recht.

gruss

[Neutral General]

Zitat:

Zitat von Zacherl (Beitrag 1386994)

Zitat:

Zitat von Neutral General (Beitrag 1386993)

Delphi-Quellcode:

MoveMemory(@buffer[K * sizeof(Short)], @A2[K], sizeof(Short));

geht auch.

Dann aber bitte ohne das

Delphi-Quellcode:

SizeOf(Short)

im Index :P

Nope. "buffer" ist ein Byte-Array ;)