Geht das nicht mehr mit dem as casten? Ich finde die richtige Syntax nicht (mehr).

TItem ist ein Record

markieren

Delphi-Quellcode:

type
  TItem = Record
    FileName: string;
    FileSize: integer;
  end;

zusammenfalten · markieren

Delphi-Quellcode:

function FileSizeCompare (Item1, Item2: Pointer): integer;
begin
  Result:= 0;
  if (Item1 as TItem).FileSize > (Item2 as TItem).FileSize then
    Result:= 1
  else
    if (Item1 as TItem).FileSize < (Item2 as TItem).FileSize then
      Result:= -1
end;


function FileNameCompare (Item1, Item2: Pointer): integer;
begin
  Result:= 0;
  if (Item1 as TItem).FileName > (Item2 as TItem).FileName then
    Result:= 1
  else
    if (Item1 as TItem).FileName < (Item2 as TItem).FileName then
      Result:= -1
end;

  List1.Sort(FileNameCompare);

As funktioniert nur mit Klassen, weder mit Pointern noch mit Records.

Ok. Thanx.

Ist das korrekt?
TItem(Item1^).FileSize

BTW, schreibt man Sort(@FileNameCompare) oder Sort(FileNameCompare) ?

Zitat von Bjoerk:

Ist das korrekt?
TItem(Item1^).FileSize

Nein. TItem(Item1).FileSize.

Zitat:

BTW, schreibt man Sort(@FileNameCompare) oder Sort(FileNameCompare) ?

Mit dem @ erlaubt der Compiler es dir, dass du statt "Pointer" direkt richtigen Typ in den Parametern nutzen kannst, da der Compiler die Typenprüfung weg lässt. Ohne das @ prüft der Compiler alle Typen.

Ui, da wäre ich nie draufgekommen (da TListSortCompare ja Items vom Typ Pointer benutzt). Many thanx Andreas. Für Sort(@FileNameCompare) kann ich also Items vom Typ TItem mitschicken.

Zitat von Bjoerk:

mitschicken.

Wohl eher "uminterpretieren". Sollte sich aber mal die API von TList.Sort ändern, bekommst das erst mit wenn das Programm zu Laufzeit kracht.

Bist du dir sicher? ich kriegs so nur mit Pointern korrekt sortiert (D2007) !?

zusammenfalten · markieren

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TItem = record
    AInteger: integer;
  end;
  TItemList = class(TList)
    function GetItem(Index: integer): TItem;
    procedure AddItem(Item: TItem);
    procedure DelItem(Index: integer);
  public
    destructor Destroy; override;
  end;
  TForm1 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    ListBox1: TListBox;
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

function TItemList.GetItem(Index: integer): TItem;
var
  PItem: ^TItem;
begin
  PItem:= Items[Index];
  Result:= PItem^;
end;

procedure TItemList.AddItem(Item: TItem);
var
  PItem: ^TItem;
begin
  New(PItem);
  PItem^:= Item;
  Add(PItem);
end;

procedure TItemList.DelItem(Index: integer);
var
  PItem: ^TItem;
begin
  PItem:= Items[Index];
  Dispose(PItem);
  Delete(Index);
end;

destructor TItemList.Destroy;
begin
  while Count > 0 do DelItem(Count-1);
end;

function AIntegerCompare1(Item1, Item2: Pointer): integer; // *** Pointer
begin
  Result:= 0;
  if TItem(Item1^).AInteger > TItem(Item2^).AInteger then
    Result:= 1
  else
    if TItem(Item1^).AInteger < TItem(Item2^).AInteger then
      Result:= -1
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  ItemList: TItemList;
  Item: TItem;
  I: integer;
begin
  Randomize;
  ItemList:= TItemList.Create;
  for I:= 1 to 100 do
  begin
    Item.AInteger:= Random(1000);
    ItemList.AddItem(Item);
    ItemList.Sort(AIntegerCompare1);
  end;
  ListBox1.Items.Clear;
  for I:= 0 to ItemList.Count-1 do
    ListBox1.Items.Add(IntToStr(ItemList.GetItem(I).AInteger));
  ItemList.Free;
end;

function AIntegerCompare2(Item1, Item2: TItem): integer; // *** Record
begin
  Result:= 0;
  if Item1.AInteger > Item2.AInteger then
    Result:= 1
  else
    if Item1.AInteger < Item2.AInteger then
      Result:= -1
end;

procedure TForm1.Button2Click(Sender: TObject);
var
  ItemList: TItemList;
  Item: TItem;
  I: integer;
begin
  Randomize;
  ItemList:= TItemList.Create;
  for I:= 1 to 100 do
  begin
    Item.AInteger:= Random(1000);
    ItemList.AddItem(Item);
    ItemList.Sort(@AIntegerCompare2);
  end;
  ListBox1.Items.Clear;
  for I:= 0 to ItemList.Count-1 do
    ListBox1.Items.Add(IntToStr(ItemList.GetItem(I).AInteger));
  ItemList.Free;
end;

end.

Zitat von Bjoerk:

Bist du dir sicher? ich kriegs so nur mit Pointern korrekt sortiert (D2007) !?

Ich schrieb doch "uminterpretiert". Wenn du also einen Record als Parameter hast, dann kann das nicht funktionieren, da TList.Sort immernoch einen Pointer übergibt, du ihn dann aber als TItem Record interpretierst (also den Pointer als TItem im Speicher typecastest).
Wenn du hingegen die Parameter als "PItem" (PItem = ^TItem) oder beide zu einem "var" Parameter machst (so das Delphi dir das "Pointer of TItem" abnimmt, geht das), weil Pointer uminterpretiert als PItem immernoch ein Pointer ist, nur hast du den richtigen Pointer-Typ.

Achso, TList.Sort benutzt bei var die entsprechenden dahinterliegenden Daten.

zusammenfalten · markieren

Delphi-Quellcode:

procedure QuickSort(SortList: PPointerList; L, R: Integer;
  SCompare: TListSortCompare);
var
  I, J: Integer;
  P, T: Pointer;
begin
  repeat
    I := L;
    J := R;
    P := SortList^[(L + R) shr 1];
    repeat
      while SCompare(SortList^[I], P) < 0 do
        Inc(I);
      while SCompare(SortList^[J], P) > 0 do
        Dec(J);
      if I <= J then
      begin
        T := SortList^[I];
        SortList^[I] := SortList^[J];
        SortList^[J] := T;
        Inc(I);
        Dec(J);
      end;
    until I > J;
    if L < J then
      QuickSort(SortList, L, J, SCompare);
    L := I;
  until I >= R;
end;

function AIntegerCompare2(var Item1, Item2: TItem): integer; // Record
begin
  Result:= 0;
  if Item1.AInteger > Item2.AInteger then
    Result:= 1
  else
    if Item1.AInteger < Item2.AInteger then
      Result:= -1
end;