我可以为 TObjectList.IndexOf 传入一个函数，为 TObjectList.Sort 传入另一个函数吗？

Question

总结：

TList.IndexOf（TList 在 Classes.pas 单元中定义）线性迭代所包含的项目，并比较引用。 TList.IndexOf（TList 在 Generics.Collections.pas 单元中定义）也线性迭代所包含的项目，但使用比较器来比较项目是否相等。

TList.Sort 和 TList.Sort 都可以使用比较器。

=====================================================

对于在以下单元中定义的 TForceList 类型的实例，我可以使用

instance.Sort(@ForceCompare);

其 Value 字段作为排序标准来对其进行快速排序。但是，当我调用时

instance.IndexOf(AnotherInstance)

，我想使用其 ElementZ 字段作为比较条件，即 ForceEqual 函数。我想知道如何才能实现这一目标？

PS：如果使用泛型集合，我想我可以使用

TList<TForce>.Create(TComparer<TForce>.Construct(ForceEqual));

单位：

    unit uChemParserCommonForce;

    interface

    uses
      uMathVector3D,
      Contnrs;

    type

      TForce = class;
      TForceList = class;

      TForce = class
      private
        FElementZ: Integer;
        FValue: TVector3D;
      public
        property ElementZ: Integer read FElementZ;
        property Value: TVector3D read FValue;
        constructor Create(aElementZ: Integer; aX, aY, aZ: Double);
        function ToString(): string; {$IF DEFINED(FPC) OR DEFINED(VER210)} override; {$IFEND}
      end;

      // Mastering Delphi 6 - Chapter 5 -
      TForceList = class(TObjectList)
      protected
        procedure SetObject(Index: Integer; Item: TForce);
        function GetObject(Index: Integer): TForce;
      public
        function Add(Obj: TForce): Integer;
        procedure Insert(Index: Integer; Obj: TForce);
        property Objects[Index: Integer]: TForce read GetObject
          write SetObject; default;
      end;

    function ForceCompare(Item1, Item2: Pointer): Integer;
    function ForceEqual(Item1, Item2: Pointer): Boolean;

    implementation

    uses
      Math, SysUtils;

    function ForceCompare(Item1, Item2: Pointer): Integer;
    begin
      // Ascendent
      //  Result := CompareValue(TForce(Item1).Value.Len, TForce(Item2).Value.Len);
      // Descendent
      Result := CompareValue(TForce(Item2).Value.Len, TForce(Item1).Value.Len);
    end;

    function ForceEqual(Item1, Item2: Pointer): Boolean;
    begin
      Result := TForce(Item1).ElementZ = TForce(Item2).ElementZ;
    end;

    constructor TForce.Create(aElementZ: Integer; aX, aY, aZ: Double);
    begin
      FElementZ := aElementZ;
      FValue := TVector3D.Create(aX, aY, aZ);
    end;

    function TForce.ToString: string;
    begin
      Result := IntToStr(FElementZ) + ' X: ' + FloatToStr(FValue.X) + ' Y: ' +
        FloatToStr(FValue.Y) + ' Z: ' + FloatToStr(FValue.Z);
    end;

    { TForceList }

    function TForceList.Add(Obj: TForce): Integer;
    begin
      Result := inherited Add(Obj);
    end;

    procedure TForceList.SetObject(Index: Integer; Item: TForce);
    begin
      inherited SetItem(Index, Item);
    end;

    function TForceList.GetObject(Index: Integer): TForce;
    begin
      Result := inherited GetItem(Index) as TForce;
    end;

    procedure TForceList.Insert(Index: Integer; Obj: TForce);
    begin
      inherited Insert(Index, Obj);
    end;

    end.

Answer 1

非泛型 TObjectList 使用 TList.IndexOf，它只是迭代内部数组并比较指针。

同样，通用 TObjectList 使用 TList.IndexOf，后者使用 IComparer。 TList.Sort 使用 TArray.Sort 传入在创建列表时分配的任何 IComparer。

比较器是私有的，仅在列表构造函数中分配，因此我没有看到覆盖此行为的简单方法。

更新

TList 提供并重载的 Sort，它接受比较器作为参数，无需修改私有比较器。因此，您可以使用一个比较器进行排序，而 indexof 可以使用不同的比较器。

Answer 2

Sort 方法背后的整个思想是它真正对列表进行排序...换句话说，在调用排序方法之后，列表中元素的物理顺序会发生更改以满足排序标准。

正如您在自己的 Delphi RTL 代码中所看到的，IndexOf 方法只是通过引用进行线性搜索，返回第一个匹配元素的物理索引。

返回的索引可用于检索列表上的对象，如下所示：

SomeIndex := AList.IndexOf(SomeObject);
//more code...
//you can re-use the reference...
//and maybe more...
SomeObject := AList[SomeIndex];

您会明白为什么，IndexOf 方法不应返回基于与列表的物理顺序不同的标准的索引...并且如果您首先调用排序，物理顺序反映了传递的排序标准。

也就是说，看起来您可能想要

• 维护两个不同的列表，按照不同的标准进行排序，并在适当的时候使用一个或另一个。
• 根据应用程序在给定时间处理的操作的适用标准对列表进行重新排序。

性能更高取决于您的应用程序如何使用这些对象、它正在处理的数据量，甚至是运行时进程可用的内存。

Answer 3

不适用于标准 TObjectList。它（实际上是基本 TList）被编写为支持使用 CustomSort 的自定义排序函数，但对于自定义 IndexOf 没有这样的规定。当然，您可以编写自己的实现方式来实现这种方式。