Upgradewunsch und Fragen zu TArray

[himitsu]

Es wäre doch OK, wenn ich mir sowas wünschen würde? (wollte mir demnächst mal einen paar QC-Einträge dazu erstellen)
Bzw. hat wer was gegen sowas oder eher noch Verbesserungsideen, bzw. andere Lösungswege?

Delphi-Quellcode:

// Unit Generics.Collections

type
  TArray = class
  public
    ...
    class procedure Sort<T>(var Values: array of T; const Comparison: TComparison<T>); overload;
    class procedure Sort<T>(var Values: array of T; const Comparison: TComparison<T>; Index, Count: Integer); overload;
    ...
    class function BinarySearch<T>(const Values: array of T; const Item: T; out FoundIndex: Integer; const Comparison: TComparison<T>; Index, Count: Integer): Boolean; overload;
    class function BinarySearch<T>(const Values: array of T; const Item: T; out FoundIndex: Integer; const Comparison: TComparison<T>): Boolean; overload;
  end;

class procedure TArray.Sort<T>(var Values: array of T; const Comparison: TComparison<T>);
begin
  Sort<T>(Values, TComparer<T>.Construct(Comparison), Low(Values), High(Values));
end;

class procedure TArray.Sort<T>(var Values: array of T; const Comparison: TComparison<T>; Index, Count: Integer);
begin
  Sort<T>(Values, TComparer<T>.Construct(Comparison), Index, Count);
end;

class function TArray.BinarySearch<T>(const Values: array of T; const Item: T; out FoundIndex: Integer; const Comparison: TComparison<T>; Index, Count: Integer): Boolean;
begin
  Result := BinarySearch<T>(Values, Item, FoundIndex, TComparer<T>.Construct(Comparison), Index, Count);
end;

class function TArray.BinarySearch<T>(const Values: array of T; const Item: T; out FoundIndex: Integer; const Comparison: TComparison<T>): Boolean;
begin
  Result := BinarySearch<T>(Values, Item, FoundIndex, TComparer<T>.Construct(Comparison), Low(Values), High(Values));
end;

Einfach, um diese Befehle direkt nutzen zu können, ohne mir erst einen Comparer erstellen zu müssen.

Delphi-Quellcode:

var 
  Liste: array of irgendwas;

TArray.Sort<irgendwas>(Liste, MyHiddenCompare);
 
// bzw.
TArray.Sort<irgendwas>(Liste, 
  function(const Left, Right: irgendwas): Integer
    begin
      //Result := MyHiddenCompare(Left, Right);
      if Left.xyz < Right.xyz then
        Result := -1
      else if Left.xyz > Right.xyz then
        Result := +1
      else
        Result := 0;
    end);

Nja, vielleicht noch ein paar fräglein dazu...
- Wieso ist der generische Parameter eigentlich an jeder einzelnen Methode dran und nicht an der Klasse? TArray<irgendwas>.Sort(...) Irgendwie empfinge ich das als unschönen "doppelten" Code.
- Und warum hat man array of T genommen und nicht TArray<T> ?
Als Var-Parameter geht ja eigentlich kein offener Array-Parameter, sodern es müßte ein stischer Typ sein.



[add]
PS: hier kann man immernoch nicht XE3 auswählen, aber eigentlich mein ich ja XE4 (weil früher wird eh wieder nix passieren)

[Uwe Raabe]

Zitat von himitsu:

- Wieso ist der generische Parameter eigentlich an jeder einzelnen Methode dran und nicht an der Klasse? TArray<irgendwas>.Sort(...) Irgendwie empfinge ich das als unschönen "doppelten" Code.

Weil das eben generische Methoden sind und keine generische Klasse.

Zitat von himitsu:

- Und warum hat man array of T genommen und nicht TArray<T> ?

Weil TArray<T> bereits als array of T deklariert ist, somit keine Klasse ist und auch keine Klassenmethoden haben kann.

[himitsu]

Zitat von Uwe Raabe:

Weil TArray<T> als bereits als array of T deklariert ist, somit keine Klasse ist und auch keine Klassenmethoden haben kann.

Arg, stimmt ja (manchmal is man einfach blind) TArray<> existiert ja schon, da kann es natürlich keine weitere Klasse dieses Typs geben.
(OK, können schon, aber wäre etwas unpraktisch)
Nja, generische Record-Helper gibt's ja leider nicht.