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>

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>

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