Sortieren eines Array of record

[ebi]

Hallo Uwe,

vielen Dank.

Wie muss ich das bei mir einbinden?

Delphi-Quellcode:

procedure TForm_Main.MyObjects_default();
var
  Din, Pal: TSteuerung;
  I: integer;
begin
  // TSteuerung: DIN
  begin
    Din := TSteuerung.Create('DIN');
    SetLength(Din.Nullpunkt, 4);
    Din.Nullpunkt[0] := 'G54';
    Din.Nullpunkt[1] := 'G55';
    Din.Nullpunkt[2] := 'G56';
    Din.Nullpunkt[3] := 'G57';
    SetLength(Din.Parameter, 0);
    SetLength(Din.TAdresse, 0);

    SetLength(Din.Wegbedingung, Length(GCodeA));
    for I := 0 to Length(GCodeA) - 1 do
      begin
        Din.Wegbedingung[I].Wort := GCodeA[I + 1].Wort;
        Din.Wegbedingung[I].Bezeichnung := GCodeA[I + 1].Bezeichnung;
      end;

    SetLength(Din.Schaltfunktion, Length(MCodeA));
    for I := 0 to Length(MCodeA) - 1 do
      begin
        Din.Schaltfunktion[I].Wort := MCodeA[I + 1].Wort;
        Din.Schaltfunktion[I].Bezeichnung := MCodeA[I + 1].Bezeichnung;
      end;
  end;

  // TSteuerung: PAL
  begin
    Pal := TSteuerung.Create('PAL');
    SetLength(Pal.Nullpunkt, 6);
    Pal.Nullpunkt[0] := 'G54';
    Pal.Nullpunkt[1] := 'G55';
    Pal.Nullpunkt[2] := 'G56';
    Pal.Nullpunkt[3] := 'G57';
    Pal.Nullpunkt[4] := 'G58';
    Pal.Nullpunkt[5] := 'G59';
    SetLength(Pal.Parameter, 0);

    SetLength(Pal.Wegbedingung, Length(GCodeB));
    for I := 0 to Length(GCodeB) - 1 do
      begin
        Pal.Wegbedingung[I].Wort := GCodeB[I + 1].Wort;
        Pal.Wegbedingung[I].Bezeichnung := GCodeB[I + 1].Bezeichnung;
      end;

    SetLength(Pal.Schaltfunktion, Length(MCodeB));
    for I := 0 to Length(MCodeB) - 1 do
      begin
        Pal.Schaltfunktion[I].Wort := MCodeB[I + 1].Wort;
        Pal.Schaltfunktion[I].Bezeichnung := MCodeB[I + 1].Bezeichnung;
      end;

    SetLength(Pal.TAdresse, Length(TCodeB));
    for I := 0 to Length(TCodeB) - 1 do
      begin
        Pal.TAdresse[I].Wort := TCodeB[I + 1].Wort;
        Pal.TAdresse[I].Bezeichnung := TCodeB[I + 1].Bezeichnung;
      end;
  end;
  MyObjects.Add(Din);
  MyObjects.Add(Pal);
end;

[himitsu]

Das wurde doch gezeigt?

Es gibt eine Sortierfunktion,
der gibt man einfach sein Array rein
und dann muß man noch irgendwie eine Vergleichsfunktion (Interface) reingeben.

Ohne Comparer wird womöglich falsch sortiert verglichen. (ohne passenden Default-Comparer wird einfach binär verglichen)
Für einfache Typen, wie Integer oder Strings, gibt es einen Default-Comparer ... für den Rest muß man selbst was generieren/übergeben.
https://docwiki.embarcadero.com/Libr...ns.TArray.Sort
https://docwiki.embarcadero.com/Libr...ults.IComparer
https://www.delphipraxis.net/191252-...sortieren.html
...

Es gibt 2 Comparer-Interfaces, einmal ala SameText, mit Boolean-Result und eben ala CompareText, mit -1, 0 oder +1 aka Kleiner, Gleich oder Größer, als Result.
Wenn Funktionen die passende Signatur (Paramerter) besitzen, wie z.B. CompareText, CompareStr, AnsiCompareStr mit 2 Parametern, dann können sie "direkt" genommen werden.

Man baut sich also ein Objekt+Interface oder packt einfach nur eine Methode in ein Delegator-Interface.

Bei mehr als einem Feld in Records, wird das einfach verschachtelt.

Delphi-Quellcode:

function(const Left, Right: TMyRecord): Integer
begin
  Result := ComareText(Left.Feld1, Right.Feld1);
  if Result = 0 then
    Result := ComareText(Left.Feld2, Right.Feld2);
  if Result = 0 then
    Result := ComareText(Left.Feld3, Right.Feld3);
  ...
end

In der Unit Math existieren auch CompareValue für Zahlen, aber man kann es auch selbst machen.

Delphi-Quellcode:

Result := ComareXXXXX(Left.Feld1, Right.Feld1);
// ala
if Left.Feld1 < Right.Feld1 then
  Result := -1
else if Left.Feld1 = Right.Feld1 then
  Result := 0
else {if Left.Feld1 > Right.Feld1 then}
  Result := +1;

Ich bin mir sicher, dass es selbst für Delphi fertige Komponenten für G-Code existieren.

[ebi]

Hallo,

bitte um Verständnis der Profis.

Mein neuer Delphi-CODE

Delphi-Quellcode:

FUNCTION TCodeSorted(Value: array of TCode): TArray<TCode>;
begin
  SetLength(Result, Length(Value));
  for var I := 0 to Length(Result) - 1 do
    Result[I] := Value[Low(Value) + I];
  TArray.Sort<TCode>(Result, TDelegatedComparer<TCode>.Create(
    FUNCTION(const Left, Right: TCode): integer
    begin
      Result := string.Compare(Left.Wort, Right.Wort, [coDigitAsNumbers]);
    end));
end;




    SetLength(TArray, Length(GCodeB));
    Zaehler := 0;

    var
    arr := TCodeSorted(GCodeB);
    for var rec in arr do
      begin
        TArray[Zaehler].Wort := rec.Wort;
        TArray[Zaehler].Bezeichnung := rec.Bezeichnung;
        Inc(Zaehler);
      end;

    SetLength(Pal.Wegbedingung, Length(TArray));
    for I := 0 to Length(TArray) - 1 do
      begin
        Pal.Wegbedingung[I].Wort := TArray[I].Wort;
        Pal.Wegbedingung[I].Bezeichnung := TArray[I].Bezeichnung;
      end;

[himitsu]

+1?
und Low+1 aka 0+1 aka immer 1?
[edit] AAAAAAHH, I nicht 1 ... schwer zu erkennen. PS: Darum verwende ich immer nur das keine i, auch wenn ich alle anderen einbuchstabigen Variablen ebenfalls groß schreibe.

Delphi-Quellcode:

for var I := 0 to High(Result) do
  Result[I] := Value[I];

param: array of ... sollte immer mit 0 beginnen, egal was reingegeben wurde.



warum nicht?

Delphi-Quellcode:

FUNCTION TCodeSorted(Value: TArray<TCode>): TArray<TCode>;
begin
  Result := Value;

oder direkt

Delphi-Quellcode:

procedure TCodeSorted(var Value: TArray<TCode>);
begin

[edit] Ahhh OK, die statischen Arrays.
Wobei man es inzwischen auch direkt dynamische Konstanten und Variablen deklarieren kann.

Delphi-Quellcode:

const  // oder var
  GCodeB: array of TCode = [
    ...
  ];

Wenn "Wort" nicht eindeutig ist und somit auch noch nach Bezeichnung sortiert werden müsste.

Delphi-Quellcode:

    begin
      Result := string.Compare(Left.Wort, Right.Wort, [coDigitAsNumbers]);
      if Result = 0 then
        Result := string.Compare(Left.Bezeichnung, Right.Bezeichnung, [coDigitAsNumbers]);
    end));

[ebi]

hallo himitsu,

vielen Dank, ich werde versuchen Dein Delphi-CODE zu erlernen.

HG

[himitsu]

Das "Warum" ignorieren ... hab ich oben editiert/geändert.

Aber bei dem +1 weist du ja immer das zweite Array-Item deinem Result zu.
Tipp: mit dem Debugger mal ansehen, was in der Result-Variable nach deiner Schleife drin steht.




Schön ist es auch, wenn man Gleiches Zusammengehöriges zusammenfasst.
So kann z.B. der Record selbst seine eigene Sortierfunktion bereitstellen.

Delphi-Quellcode:

type
  TCode = record
    Wort: string;
    Bezeichnung: string;
    class function Compare(const Left, Right: TCode): Integer; static;
  end;

// das Class+Static ist dafür, damit es kein implizites SELF gibt (als ersten unsichtbaren Parameter), also genauso, als wäre die Methode nicht in einer Klasse/Record.
class function TCode.Compare(const Left, Right: TCode): Integer;
begin
  Result := string.Compare(Left.Wort, Right.Wort, [coDigitAsNumbers]);
end;


TArray.Sort<TCode>(Self.TAdresse, TDelegatedComparer<TCode>.Create(TCode.Compare));

PS: Der Name mit T ist schon ein bissl verwirrend ... klingt irgendwie nicht nach Feld/Variable, sondern mehr nach Typ/Klasse.

[Uwe Raabe]

Zitat von himitsu:

Wobei man es inzwischen auch direkt dynamische Konstanten und Variablen deklarieren kann.

Delphi-Quellcode:

const  // oder var
  GCodeB: array of TCode = [
    ...
  ];

Wird nicht so einfach mit einem array of record...

[himitsu]

OK, vor allem in Bezug auf Records gibt es hier immer mal wieder Verwirrungen, bei der Deklaration.
https://quality.embarcadero.com/brow...ord%20const%22

Aber meistens oft lässt es sich schon verwenden, abgesehn von anderen Dingen.
https://embt.atlassian.net/servicede...tal/1/RSS-1691

[ebi]

Hallo Zusammen,

Euer Profi Delphi-CODE ist schon eine starke Sache, nur für mich nicht klar,
wo was jetzt genau hinkommt.

Vielen Dank.

HG