2 Arrays vergleichen\sortieren

[Uwe Raabe]

Zitat von TiGü:

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

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
A1, A2: TArray<TgObj>;

A1, A2: TArray<SmallInt>;
Dann habe ich aber keinen zugriff auf die Variablen des Record.
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 von 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.

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.

[EWeiss]

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

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?