2 Arrays vergleichen\sortieren

[EWeiss]

Ich möchte dies beiden werte vergleichen.

Delphi-Quellcode:

while (A1[nB] < A1[nPiv]) do
  inc(nB);

Delphi-Quellcode:

while (A1[nE] > A1[nPiv]) do
  dec(nE);

A1 ist ein Array of TArray<MyRecord>

Delphi-Quellcode:

procedure TSkinSpriteContainer.SortShortTagArray(var A1, A2: TArray<TgObj>; Count: Integer);

Fehler..

Zitat:

[DCC Fehler] E2015 Operator ist auf diesen Operandentyp nicht anwendbar

sorry habe mit dem Array Type TArray noch keine Erfahrung.

Unter C++ mit

Code:

vector<short> &A1, vector<short> &A2

funktioniert das.

Das vertauschen beider Arrays will auch nicht so recht.

Delphi-Quellcode:

if (nB < nE) then
begin
  swap(A1[nB], A1[nE]);
  swap(A2[nB], A2[nE]);
end;

Delphi-Quellcode:

procedure SWAP(var Value1, Value2: TArray<TgObj>);
var
  lTemp: TArray<TgObj>;

begin
  lTemp := Value1;
  Value1 := Value2;
  Value2 := lTemp;
end;

irgenwo hängt es immer. LOL

gruss

[Uwe Raabe]

Zitat:

[DCC Fehler] E2015 Operator ist auf diesen Operandentyp nicht anwendbar

Gibt es denn eine Implementation für den Vergleich kleiner/größer by MyRecord bzw. TgObj?

Die C-Deklaration mit vector<short> suggeriert, daß es sich um einen Integertyp handelt. Bei TArray<ShortInt> gäbe es in Delphi auch keine Probleme. Also was ist TgObj?

-----------------

Beim Swap werden ja nicht die Arrays getauscht, sondern die Elemente. Also müsste das so gehen:

Delphi-Quellcode:

procedure SWAP(var Value1, Value2: TgObj);
var
  lTemp: TgObj;

begin
  lTemp := Value1;
  Value1 := Value2;
  Value2 := lTemp;
end;

Übrigens: Swap ist in Delphi eine intrinsische Funktion. Deswegen würde ich hier einen anderen Namen (z.B. SwapTgObj) empfehlen.

[EWeiss]

Zitat:

Übrigens: Swap ist in Delphi eine intrinsische Funktion. Deswegen würde ich hier einen anderen Namen (z.B. SwapTgObj) empfehlen.

Ok das kann ich ändern. Danke.
Hier hab ich jetzt keinen Fehler mehr..

Ich dachte hätte das beschrieben ;)
A1 ist ein Array of TArray<MyRecord>

Delphi-Quellcode:

g_Obj: TArray<TgObj>;

Delphi-Quellcode:

  TgObj = record
    ID: Integer;
    Handle: HWND;
    ObjType: Integer;
    UseSize: Integer;
    ARGB: COLORREF;
    Use3d: Short;
    Style: DWORD;
    X1: Integer;
    X2: Integer;
    Y1: Integer;
    Y2: Integer;
    Clone: Integer;
    Region: HRGN;
    metadata: array [0..2047] of Byte;
    Metacount: Integer;
    Scale: Single;
    Framecount: Byte;
    Frametouse: Byte;
    .... - >

Beispiel:

Delphi-Quellcode:

function TSkinSpriteContainer.GetObjectOrder(hParent: HWND): Integer;
var
  gP, UB: Integer;
  K, Count: Integer;
  A1, A2: TArray<TgObj>;
  buffer: array [0 .. 2048] of char;
begin
  Count := 0;

  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
  begin
    // vector<short> A1(UB), A2(UB);
    SetLength(A1, UB);
    SetLength(A2, UB);

    for K := 0 to UB do
    begin
      if (g_Obj[K].Handle = hParent) then
      begin
        SetLength(A1, Count + 1);
        SetLength(A2, Count + 1);

        A1[Count].Order := g_Obj[K].Order;
        inc(Count);
      end;
    end;

    SortShortTagArray(A1, A2, Count);

    for K := 0 to Count do
      MoveMemory(@(buffer[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;
  end;
  Result := gP;
end;

gruss

[TiGü]

Die sogenannten class operatoren musst du für den jeweiligen Record-Typ selber implementieren.
Da wo als Kommentar

Delphi-Quellcode:

//...usw. usf.

steht, musst du selber die weiteren Kriterien definieren.

Delphi-Quellcode:

program Project3;

{$APPTYPE CONSOLE}

{$R *.res}


uses
  System.SysUtils,
  Winapi.Windows;

type
  TgObj = record
    ID: Integer;
    Handle: HWND;
    ObjType: Integer;
    UseSize: Integer;
    ARGB: COLORREF;
    Use3d: Short;
    Style: DWORD;
    X1: Integer;
    X2: Integer;
    Y1: Integer;
    Y2: Integer;
    Clone: Integer;
    Region: HRGN;
    metadata: array [0 .. 2047] of Byte;
    Metacount: Integer;
    Scale: Single;
    Framecount: Byte;
    Frametouse: Byte;

    class operator Equal(const A, B: TgObj): Boolean;
    class operator NotEqual(const A, B: TgObj): Boolean;
    class operator GreaterThan(const A, B: TgObj): Boolean;
    class operator LessThan(const A, B: TgObj): Boolean;
    class operator GreaterThanOrEqual(const A, B: TgObj): Boolean;
    class operator LessThanOrEqual(const A, B: TgObj): Boolean;
  end;

var
  A, B: TgObj;

  { TgObj }

class operator TgObj.Equal(const A, B: TgObj): Boolean;
begin
  Result := (A.ID = B.ID) and (A.Handle = B.Handle); // ...usw. usf.
end;

class operator TgObj.GreaterThan(const A, B: TgObj): Boolean;
begin
  Result := (A.ID > B.ID) and (A.Handle > B.Handle); // ...usw. usf.
end;

class operator TgObj.GreaterThanOrEqual(const A, B: TgObj): Boolean;
begin
  Result := (A.ID >= B.ID) and (A.Handle >= B.Handle); // ...usw. usf.
end;

class operator TgObj.LessThan(const A, B: TgObj): Boolean;
begin
  Result := (A.ID < B.ID) and (A.Handle < B.Handle); // ...usw. usf.
end;

class operator TgObj.LessThanOrEqual(const A, B: TgObj): Boolean;
begin
  Result := (A.ID <= B.ID) and (A.Handle <= B.Handle); // ...usw. usf.
end;

class operator TgObj.NotEqual(const A, B: TgObj): Boolean;
begin
  Result := (A.ID <> B.ID) and (A.Handle <> B.Handle); // ...usw. usf.
end;

begin
  try
    FillChar(A, SizeOf(A), 0);
    FillChar(B, SizeOf(B), 0);

    A.ID := $BEEF;
    B.ID := $DEAD;

    A.Handle := $C001;
    B.Handle := $BA55;

    Writeln('A < B: ', A < B);
    Writeln('A > B: ', A > B);
    Writeln('A = B: ', A = B);
    Writeln('A <> B: ', A <> B);

    Readln;
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;

end.

[EWeiss]

Danke werde das mal nachverfolgen.
Ist das ein Ansatz der Sortierfunktion?

Die habe ich in Delphi so umgelegt.. (Ohne gewähr das es korrekt ist.)

C++

Code:

void SortShortTagArray (OUT vector<short> &A1, OUT vector<short> &A2, IN long nCount) {
    long nStack[1000] = {0};
    long nBeg = 0;
    long nEnd = nCount - 1;
    long nB, nE, nS, nPiv;
    nB = nE = nS = nPiv = 0;

    do {
        do {
            nPiv = (long) ((nEnd + nBeg) / 2);
            nB = nBeg;
            nE = nEnd;
            do {
                while (A1[nB] < A1[nPiv]) {
                    ++nB;
                }
                while (A1[nE] > A1[nPiv]) {
                    --nE;
                }
                if (nB > nE) { break; }
                if (nB < nE) {
                    swap(A1[nB],A1[nE]);
                    swap(A2[nB],A2[nE]);
                }
                ++nB;
                --nE; }
            while (nB <= nE);

            if (nB < nEnd) {
                nStack[nS] = nB;
                nStack[nS + 1] = nEnd;
                nS += 2;
            }
            nEnd = nE;}
        while (nBeg < nEnd);

        if (nS == 0) { break; }
        nS -= 2;
        nBeg = nStack[nS];
        nEnd = nStack[nS + 1]; }

    while(-1);

}

Delphi..

Delphi-Quellcode:

procedure TSkinSpriteContainer.SortShortTagArray(var A1, A2: TArray<TgObj>; Count: Integer);
var
  nStack: array [0..1000] of Integer;
  nBeg, nEnd: Integer;
  nB, nE, nS, nPiv: Integer;
begin

  nBeg := 0; nS := 0; nB := 0; nE := 0; nPiv := 0;

  nEnd := Count - 1;
  FillChar(nStack, sizeof(nStack), 0);

  while(true) do
  begin
    while (nBeg < nEnd) do
      begin
      nPiv := (nEnd + nBeg) div 2;
      nB := nBeg;
      nE := nEnd;

      while (nB <= nE) do
         begin
//        while (A1[nB] < A1[nPiv]) do << will nicht
//          inc(nB);
//
//        while (A1[nE] > A1[nPiv]) do << will nicht
//          dec(nE);

        if (nB > nE) then
              break;

        if (nB < nE) then
        begin
          SwapTgObj(A1[nB], A1[nE]);
          SwapTgObj(A2[nB], A2[nE]);
        end;
        inc(nB);
        dec(nE);
         end;

      if (nB < nEnd) then
         begin
        nStack[nS] := nB;
        nStack[nS + 1] := nEnd;
        nS := nS + 2;
      end;
      nEnd := nE;
      end;

    if (nS = 0) then
        break;

    nS := nS - 2;
    nBeg := nStack[nS];
    nEnd := nStack[nS + 1];
  end;
end;

procedure TSkinSpriteContainer.SwapTgObj(var Value1, Value2: TgObj);
var
  lTemp: TgObj;

begin

  lTemp := Value1;
  Value1 := Value2;
  Value2 := lTemp;
end;

Muss ihn mal fragen was genau er hier sortiert.
Mit den A,B,C variablen komm ich nicht zurecht sind nicht Aussage kräftig in seinem Code Schnipsel.

gruss

[TiGü]

Was willst du denn eigentlich erreichen?
Wollen wir vielleicht über das Problem reden, anstatt irgendeine Lösung ans Laufen zu bekommen, die ggf. gar nicht passt?

Bedenke, du willst ein Array mit einen komplexen Daten-Container sortieren/vergleichen und das C++ Beispiel zeigt zwei Vektoren-Klassen mit einer einfachen Ganzzahl (short -> Word in Delphi).

[EWeiss]

Zitat:

Was willst du denn eigentlich erreichen?

Ich habe mal das prog OTB in Delphi geschrieben.
Das beinhaltet eine Sprite Engine die anstelle von Fenster nur Grafik Objekte verwendet.
Das Problem dabei ist das ich diese für jede Anwendung von Hand copy\paste dort neu einfügen muss.

Das möchte ich jetzt verhindern und versuche mich an einer existierenden Engine die ich aus meiner DLL als Interface übergeben will.
Was ich erreichen will ist den C++ Code nach Delphi zu portieren, möchte also das RAD nicht neu erfinden.

Ich habe also versucht vector<GOBJECT> nach Delphi umzulegen und das einzige vergleichbare dazu ist TArray<MyRecord>.
Siehe Shot.. Das Kontakt Blatt basiert auf der OTB engine und die möchte ich jetzt ändern.

c++

Code:

vector<GOBJECT> g_Obj;

es ist kein short sondern vector<struct> g_Obj.
Andernfalls hätte ich doch keinen zugriff auf die einzelnen variablen von g_Obj.

Meine Engine in Delphi ist so definiert.

Delphi-Quellcode:

Sprites: TObjectList<TSprite>; // << Class TSprite.

Code:

vector<short> &A1, vector<short> &A2

Ja A1 und A2 sind short dienen aber nur dazu um das Array(Record) zu sortieren. (Nach welchen Kriterien muss ich noch nachfragen)


gruss

[Uwe Raabe]

Zitat:

Zitat von TiGü (Beitrag 1386879)

Bedenke, du willst ein Array mit einen komplexen Daten-Container sortieren/vergleichen und das C++ Beispiel zeigt zwei Vektoren-Klassen mit einer einfachen Ganzzahl (short -> Word in Delphi).

Das wollte ich ja oben bereits auch schon ausdrücken.

Was ist denn das eigentliche Sortierkriterium für TgObj? Wird das z.B. nach dem Feld ID sortiert? In dem Fall könnte man die Vergleiche auch ganz ausschreiben und sich die Operatoren im Record sparen. Die auskommentierten Zeilen müssten dann so lauten:

Delphi-Quellcode:

   while (A1[nB].ID < A1[nPiv].ID) do 
     inc(nB);
  
   while (A1[nE].ID > A1[nPiv].ID) do
     dec(nE);

Zitat:

Zitat von EWeiss (Beitrag 1386882)

es ist kein short sondern vector<struct> g_Obj.

In dem Code, den du gepostet hast, steht aber schon vector<short>, oder?

Zitat:

void SortShortTagArray (OUT vector<short> &A1, OUT vector<short> &A2, IN long nCount) {

[EWeiss]

Zitat:

In dem Code, den du gepostet hast, steht aber schon vector<short>, oder?

richtig

Code:

vector<short> &A1, vector<short> &A2

Ja A1 und A2 sind short dienen aber nur dazu um das Array(Record) zu sortieren. (Nach welchen Kriterien muss ich noch nachfragen)

Siehe dazu nochmal zum besseren Verständnis.

Delphi-Quellcode:

function TSkinSpriteContainer.GetObjectOrder(hParent: HWND): Integer;
var
  gP, UB: Integer;
  K, Count: Integer;
  A1, A2: TArray<TgObj>;
  buffer: array [0 .. 2048] of char;
begin
  Count := 0;

  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
  begin
    SetLength(A1, UB);
    SetLength(A2, UB);

    for K := 0 to UB do
    begin
      if (g_Obj[K].Handle = hParent) then
      begin
        SetLength(A1, Count + 1);
        SetLength(A2, Count + 1);

        A1[Count].Order := g_Obj[K].Order;
        inc(Count);
      end;
    end;

    SortShortTagArray(A1, A2, Count);

    for K := 0 to Count do
      MoveMemory(@(buffer[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;
  end;
  Result := gP;
end;

eventuell liegt hier schon mein Denkfehler

Delphi-Quellcode:

A1, A2: TArray<TgObj>;

A1, A2: TArray<SmallInt>;
Dann habe ich aber keinen zugriff auf die Variablen des Record.

Delphi-Quellcode:

A1[Count].Order := g_Obj[K].Order;

gruss

[TiGü]

Du hast da einen grundlegenden Denkfehler und/oder Verständnisproblem.
Aber ich weiß nicht wie man es dir erklären kann, ohne das es gleich wieder ausartet oder man ein kindisches LOL erhält. :(

[EWeiss]

Zitat:

Zitat von TiGü (Beitrag 1386885)

Du hast da einen grundlegenden Denkfehler und/oder Verständnisproblem.
Aber ich weiß nicht wie man es dir erklären kann, ohne das es gleich wieder ausartet oder man ein kindisches LOL erhält. :(

Denke ich auch sonst müsste ich nicht hier Nachfragen ;)

Versuch es einfach.
Verspreche nicht zu meckern. ;)

gruss

[TiGü]

Am Besten zeigst du uns einfach den Aufruf von SortShortTagArray im C++ Quelltext.
Damit man mal den Kontext sieht. Sonst ist es wieder nur Glaskugelwischen.
:glaskugel:

[EWeiss]

Zitat:

Zitat von TiGü (Beitrag 1386888)

Am Besten zeigst du uns einfach den Aufruf von SortShortTagArray im C++ Quelltext.
Damit man mal den Kontext sieht. Sonst ist es wieder nur Glaskugelwischen.
:glaskugel:

Hier.. Danke.
Die Sort Funktion war hier..
http://www.delphipraxis.net/1386876-post5.html

btw.. Es soll niemand für mich übersetzen benötige nur Hilfestellungen. :)

Code:

long GetObjectOrder (IN HWND hParent) {

    long pZP = gPropertyItem(hParent);
    if (pZP > -1) {
        if (g_Prop[pZP].ordersize) {
            return pZP;
        }
    }

    long UB = UBOUND(g_zObj);
    if (UB > 0) {
        long K = 0, nCount = 0;
        vector<short> A1(UB), A2(UB);
        for (K = 0; K < UB; K++) {
            if (g_zObj[K].hwnd == hParent) {
                A1[nCount] = (short) (g_zObj[K].order); A2[nCount] = (short) (K);
                nCount += 1;
            }
        }
        //ARRAY SORT A1() FOR nCount, TAGARRAY A2();
        SortShortTagArray (A1, A2, nCount); // hier!

        char buffer[2048] = {0};
        for (K = 0; K < nCount; K++) {
            MoveMemory(&buffer[0] + K * sizeof(short) , &A2[K], sizeof(short));
        }
        A1.clear(); A2.clear();

        if (pZP < 0) {
            // REDIM PRESERVE g_Prop[1 TO pZP) AS ZIMAGEPROP
            pZP = (long) (UBOUND(g_Prop));
            g_Prop.resize(pZP + 1);
        }
        g_Prop[pZP].hWnd      = hParent;
        MoveMemory(&g_Prop[pZP].order, &buffer[0], sizeof(buffer));
        g_Prop[pZP].ordersize = nCount; // nCount * 2;
    }
    return pZP;
}

gruss

[TiGü]

Achte mal auf die Zeile:

Code:

vector<short> A1(UB), A2(UB);

Was für ein Datentyp liegt hier vor?

[EWeiss]

Zitat:

Zitat von TiGü (Beitrag 1386891)

Achte mal auf die Zeile:

Code:

vector<short> A1(UB), A2(UB);

Was für ein Datentyp liegt hier vor?

short (SmallInt) Delphi denk ich mal.

EDIT:
Aber wenn ich es so definiere bekomme ich keinen zugriff mehr auf die Variablen des Record.

Delphi-Quellcode:

A1[Count].Order := g_Obj[K].Order;

Würde dann nicht mehr funktionieren.

Zitat:

[DCC Fehler] uSpriteContainer.pas(2630): E2018 Record, Objekt oder Klassentyp erforderlich

gruss

[Uwe Raabe]

Ich bin jetzt nicht so der C++ Spezialist, aber für mich sieht das so aus, als enthalten die Arrays nicht die Records sondern A1 enthält jeweils das Order-Feld und A2 den Index des Records. Was dann allerdings damit passiert entzieht sich noch meinem Verständnis. Da mögen doch jetzt besser die C++ Cracks ran - das ist dann nichts für mich.

[EWeiss]

Zitat:

Zitat von Uwe Raabe (Beitrag 1386893)

Ich bin jetzt nicht so der C++ Spezialist, aber für mich sieht das so aus, als enthalten die Arrays nicht die Records sondern A1 enthält jeweils das Order-Feld und A2 den Index des Records. Was dann allerdings damit passiert entzieht sich noch meinem Verständnis. Da mögen doch jetzt besser die C++ Cracks ran - das ist dann nichts für mich.

Trotzdem Danke für deine Hilfe ;)
Habe noch Hoffnung das Zacherl mal drüber schaut wenn er zeit dafür findet.

Es sieht so aus das er nach der ID sortiert.
Sicher bin ich mir jedoch nicht.

Zitat:

I am using it to sort a secondary array in the same order than the main one.
it is used for sorting the z-order of the sprites unique ID.

Es soll so funktionieren wie wenn man eine ListBox sortiert über

Zitat:

That works the same than using a sorted LISTBOX with LB_SETITEMDATA or LB_GETITEMDATA,

gruss

[Zacherl]

Zitat:

Zitat von EWeiss (Beitrag 1386894)

Zitat:

Zitat von Uwe Raabe (Beitrag 1386893)

Ich bin jetzt nicht so der C++ Spezialist, aber für mich sieht das so aus, als enthalten die Arrays nicht die Records sondern A1 enthält jeweils das Order-Feld und A2 den Index des Records. Was dann allerdings damit passiert entzieht sich noch meinem Verständnis. Da mögen doch jetzt besser die C++ Cracks ran - das ist dann nichts für mich.

Trotzdem Danke für deine Hilfe ;)
Habe noch Hoffnung das Zacherl mal drüber schaut wenn er zeit dafür findet.

Es sieht so aus das er nach der ID sortiert.

Stimme Uwe zu. Sortiert wird letztlich über

Delphi-Quellcode:

g_zObj[K].order

, wie ich das sehe.

Delphi-Quellcode:

A1

scheint jeweils die `order` und

Delphi-Quellcode:

A2

den dazugehörigen Index zu enthalten.

[EWeiss]

Zitat:

Zitat von Zacherl (Beitrag 1386904)

Zitat:

Zitat von EWeiss (Beitrag 1386894)

Zitat:

Zitat von Uwe Raabe (Beitrag 1386893)

Ich bin jetzt nicht so der C++ Spezialist, aber für mich sieht das so aus, als enthalten die Arrays nicht die Records sondern A1 enthält jeweils das Order-Feld und A2 den Index des Records. Was dann allerdings damit passiert entzieht sich noch meinem Verständnis. Da mögen doch jetzt besser die C++ Cracks ran - das ist dann nichts für mich.

Trotzdem Danke für deine Hilfe ;)
Habe noch Hoffnung das Zacherl mal drüber schaut wenn er zeit dafür findet.

Es sieht so aus das er nach der ID sortiert.

Stimme Uwe zu. Sortiert wird letztlich über

Delphi-Quellcode:

g_zObj[K].order

, wie ich das sehe.

Delphi-Quellcode:

A1

scheint jeweils die `order` und

Delphi-Quellcode:

A2

den dazugehörigen Index zu enthalten.

Wie würde das dann aussehen.. Sorry ;)

gruss

[Zacherl]

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

Delphi-Quellcode:

function GetObjectOrder(hParent: HWND): LongInt;
var
  pZP, UB, K, nCount: LongInt;
  A1, A2: TArray<ShortInt>;
  buffer: array[0..2048 - 1] of Byte;
begin
  pZP := gPropertyItem(hParent);
  if (pZP > -1) then
  begin
    if (g_Prop[pZP].ordersize > 0) then
    begin
      Exit(pZP);
    end;
  end;

  UB = UBOUND(g_zObj);
  if (UB > 0) then
  begin
    K = 0;
    nCount := 0;
    SetLength(A1, UB);
    SetLength(A2, UB);
    for K := 0 to UB - 1 do
    begin
      if (g_zObj[K].hwned = hParent) then
      begin
        A1[nCount] := SmallInt(g_zObj[K].order);
        A2[nCount] := SmallInt(K);
        nCount := nCount + 1;
      end;
    end;

    SortShortTagArray(A1, A2, nCount);

    ZeroMemory(@buffer[0], SizeOf(buffer));
    for K := 0 to nCount - 1 do
    begin
      CopyMemory(PByte(@buffer[0]) + K * SizeOf(SmallInt), @A2[K], SizeOf(ShortInt));
    end;
    SetLength(A1, 0);
    SetLength(A2, 0);

    if (pZP < 0) then
    begin
      pZP := LongInt(UBOUND(g_Prop));
      g_Prop.resize(pZP + 1);
    end;
    g_Prop[pZP].hWnd := hParent;
    CopyMemory(@g_Prop[pZP].order, @buffer[0], SizeOf(buffer));
    g_Prop[pZP].ordersize := nCount;
  end;
  Result := pZP;
end;

[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 ;)

[EWeiss]

Zitat:

Zitat von Neutral General (Beitrag 1386997)

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

ja?
Char <> Byte?

Delphi-Quellcode:

buffer: array [0 .. 2047] of Char;

gruss

[Neutral General]

Char wird in C/C++ als Ersatz für Byte benutzt. D.h. für Delphi 2009+ "Char" ist sogar explizit der falsche Datentyp weil er doppelt so groß ist wie das "char" in C++.
Du solltest es als Array[0..2047] of Byte übersetzen.

[EWeiss]

Zitat:

Zitat von Neutral General (Beitrag 1386999)

Char wird in C/C++ als Ersatz für Byte benutzt. D.h. für Delphi 2009+ "Char" ist sogar explizit der falsche Datentyp weil er doppelt so groß ist wie das "char" in C++.
Du solltest es als Array[0..2047] of Byte übersetzen.

Ahh danke das könnte einige meiner Probleme lösen ;)
Dann hatte ich hie schon den ersten Fehler.

Delphi-Quellcode:

MoveMemory(@Item, g_Prop[gP].order + K * sizeof(short), sizeof(short));
MoveMemory(@Item, PByte(@g_Prop[gP].order) + K * sizeof(short), sizeof(short));

Aber das Item inkrementiert immer noch nicht.
Na ja werde mal schauen.


gruss

[Zacherl]

Zitat:

Zitat von Neutral General (Beitrag 1386997)

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

Stimmt :-D In dem Falle würde ich dann den Buffer aber tatsächlich direkt mit

Delphi-Quellcode:

Short

statt

Delphi-Quellcode:

Byte

deklarieren. Macht auch von der Logik her mehr Sinn.

[EWeiss]

Zitat:

Zitat von Zacherl (Beitrag 1387001)

Zitat:

Zitat von Neutral General (Beitrag 1386997)

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

Stimmt :-D In dem Falle würde ich dann den Buffer aber tatsächlich direkt mit

Delphi-Quellcode:

Short

statt

Delphi-Quellcode:

Byte

deklarieren. Macht auch von der Logik her mehr Sinn.

Bei Short ist Item 65535 groß muss aber 0 sein ;) :?:
Ok dann werde ich Item auch als short definieren müssen.

gruss

[Neutral General]

Emil denk nach bevor du was tust! (sorry :?)
Wenn du den Buffer als Array of Short deklarierst musst du natürlich die Länge des Arrays halbieren und du musst bei der Indizierung aufpassen!

Nur die Deklaration zu ändern bringt Chaos.

[EWeiss]

Zitat:

Zitat von Neutral General (Beitrag 1387005)

Emil denk nach bevor du was tust! (sorry :?)
Wenn du den Buffer als Array of Short deklarierst musst du natürlich die Länge des Arrays halbieren und du musst bei der Indizierung aufpassen!

Nur die Deklaration zu ändern bringt Chaos.

Danke für den Hinweis. Das wusste ich nicht
Ich versuche es :)

gruss

[EWeiss]

Trotz alledem auch wenn einige denken (Uwe Rabe als Beispiel) das ich blöd wäre habe ich mit meiner alten Sprite Engine meinen Video Player fertig gestellt.

Zitat:

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

Das ich es mir jetzt etwas einfacher machen will nun da kann ich nur draus lernen.
Das Delphi nicht gleich C++ ist, ist mir auch bekannt.

Na was soll's. ich kann damit leben.
Wollte das nur gesagt haben.

gruss

[Uwe Raabe]

Zitat:

Zitat von EWeiss (Beitrag 1387021)

Trotz alledem auch wenn einige denken (Uwe Rabe als Beispiel) das ich blöd wäre

Habe ich nie behauptet! Das war lediglich ein wohlmeinender Kommentar auf deine Äußerungen:

Zitat:

langsam nervt Delphi nur noch
...
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.
...
Also warum funktioniert es unter C++ und nicht mit Delphi.
...
Um so mehr ich mit C++ Arbeite um so mehr stelle ich fest wie verkorkst die Sprache Delphi(Compiler) eigentlich ist.

Solche Kommentare höre ich häufig von Leuten, die mit C++ gut zurecht kommen, aber halt mit Delphi ihre Probleme haben. Das liegt weder an C++ noch an Delphi noch an den Leuten, sondern einfach an der Kombination. Das macht diese Leute auch nicht blöd oder doof - das hat einfach was mit der Denkweise zu tun. Ich würde mich sicher genauso schwer tun, wenn ich mit C++ arbeitete. Deswegen muss ich diese Sprache ja nicht gleich für hirnrissig erklären. Wenn du eine Reaktion wie die meine nicht haben willst, dann halte dich doch einfach an dein eigenen Worte:

Zitat:

Jetzt keinen erneuten Hype um Delphi hier sachlich bleiben.

[EWeiss]

Zitat:

Habe ich nie behauptet!

Aber es kam so rüber.

Zitat:

Wenn du eine Reaktion wie die meine nicht haben willst, dann halte dich doch einfach an dein eigenen Worte:

Ich denke auch, aber weist du das kam so abfällig herüber.. vielleicht solltest du deine Wortwahl auch einmal überdenken.

Nichts destotrotz hat sich erledigt und ich bin niemanden böse das er sich wehrt wenn es um sein geliebtes Delphi geht. (Ich werde es in der Zukunft unterlassen)
Ich bin kein Profi will das nochmal in den Raum stellen.

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.

Dabei wie gesagt ist es eine einfach Win32 API wo man sich am ende auch nicht schlüssig ist
was denn nun MoveMemory oder CopyMemory wobei beides das gleiche ist.


gruss