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)