Listenobjekte sortieren

[Relicted]

Daher empfehle ich immer typisierte Listen...

Mach dir mal nen Project1.dpr und mach nen Loadfromfile in ne Stringliste und mach für jede Zeile nen Format( Liste[i],[Edit1.text] );
In das Edit schreibste dann einfach den Namen der Klasse (ohne das T am Anfang) für die die Liste sein soll... Hier mein "Template"

Delphi-Quellcode:

unit %sList;
                                                                                        
interface                                                                               
                                                                                        
uses                                                                                    
  Contnrs,                                                                              
  %s;                                                                        
                                                                                        
type                                                                                    
  T%sList = class( TObjectList )                                             
  protected                                                                             
    //* Protected functions..                                                           
    function GetItem(Index: Integer): T%s; reintroduce;                      
    procedure SetItem(Index: Integer; const Value: T%s); reintroduce;        
  public                                                                                
    //* Constructors.. don't forget to call "inherited"                                
    //constructor Create; overload;                                                     
    //constructor Create(AOwnsObjects: Boolean); overload;                              
                                                                                        
    //* List Functions & Propertys                                                      
    function Add(AObject: T%s): Integer; reintroduce;                        
    function Extract(Item: T%s): T%s; reintroduce;                
    function Remove(AObject: T%s): Integer; reintroduce;                     
    function IndexOf(AObject: T%s): Integer; reintroduce;                    
    procedure Insert(Index: Integer; AObject: T%s); reintroduce;             
    function First: T%s; reintroduce;                                        
    function Last: T%s; reintroduce;                                         
    property Items[Index: Integer]: T%s read GetItem write SetItem; default; 
                                                                                        
    //* Insert your own functions here...                                               
  end;                                                                                  
                                                                                        
implementation                                                                          

uses
  Windows,
  SysUtils;

{ T%sList }                                                                  
                                                                                        
function T%sList.Add(AObject: T%s): Integer;                      
begin                                                                                   
  result := inherited Add( AObject );                                                   
end;                                                                                    
                                                                                        
function T%sList.Extract(Item: T%s): T%s;              
begin                                                                                   
  result := inherited Extract( Item ) as T%s;                                
end;                                                                                    
                                                                                        
function T%sList.First: T%s;                                      
begin                                                                                   
  result := inherited First as T%s;                                          
end;                                                                                    
                                                                                        
function T%sList.GetItem(Index: Integer): T%s;                    
begin                                                                                   
  result := inherited GetItem( Index ) as T%s;                               
end;                                                                                    
                                                                                        
function T%sList.IndexOf(AObject: T%s): Integer;                  
begin                                                                                   
  result := inherited IndexOf( AObject );                                               
end;                                                                                    
                                                                                        
procedure T%sList.Insert(Index: Integer; AObject: T%s);           
begin                                                                                   
  inherited Insert(Index,AObject);                                                      
end;                                                                                    
                                                                                        
function T%sList.Last: T%s;                                       
begin                                                                                   
  result := inherited Last as T%s;                                           
end;                                                                                    
                                                                                        
function T%sList.Remove(AObject: T%s): Integer;                   
begin                                                                                   
  result := inherited Remove(AObject);                                                  
end;                                                                                    
                                                                                        
procedure T%sList.SetItem(Index: Integer;                                    
  const Value: T%s);                                                         
begin                                                                                   
  inherited SetItem(Index,Value);                                                       
end;                                                                                    

end.

Damit fällt dann das ekelige Typecasten TMyObject() weg!

Gruß
Reli

[Tod787]

@DeddyH

verstehe nicht was du damit meinst. So hab ich es doch gemacht. Oder haben wir uns zeitlich überschnitten?

Zitat von DeddyH:

Und beiTMyObject(MyObjectlist.Items[i]).Groesse ?

@Relicted
also eigentlich funktioniert das jetzt bei mir aber das mit der Typisierung interessiert mich zwar schon, weiß aber nicht so recht was du mir damit sagen willst. Auf den ersten Blick sieht das für mich komplizierter aus.

[DeddyH]

Jepp, war eine Überschneidung.

[Relicted]

Hier ich hab das ganze mal schnell in ein "Dreckstool" verpackt.

Es geht einfach darum, dass du den Typecast nicht in jedem Funktionsaufruf machst sondern deine Objekte (TMeinObjekt), die du in die TObjectList reingesteckt hast, auch als TMeinObjekt zurück bekommst anstatt als TObject. Also du nicht immer TMeinObjekt( MeineListe.Items[i] ).Groesse schreiben musst sondern einfach nur noch MeineListe.Items[i].Groesse schreiben kannst.

Führ mal das Programm aus, gib den Namen deiner Klasse ein und erstell ne neue Unit. Die bindest du dann über "uses" bei dir im Projekt ein. Dann ersetzt du überall wo TObjectList vorkommt mit TMeineListe (also so wie du dein objekt benannt hast + liste) und dann kannst du alle TMeinObjekt() wegmachen.

Weiterer Vorteil dieser Liste: du hast immer die Gewissheit dass in der Liste auch wirklich nur "TMeinObjekt"e drinstecken. In eine "normale" TObjectList kannst du halt auch TRelisObjekt, TDeddysObjekt und TIchwaergerneinObjekt reinpacken. Raus bekommste aber immer ein TObject und wenn du dann versuchst TDeddysObjekt auf TMeinObjekt zu casten knallts

Gruß
Reli

[Tod787]

Sehr feine Sache! Jetzt weiß ich auch was du gemeint hast. Getestet, funktioniert und für sehr brauchbar eingestuft!!! Danke für die Geduld! Achja und von wegen "Dreckstool"... also mir gefällts

[Relicted]

Kein Problem, naja Dreckstool halt weil Quick and Dirty eben hingeklatscht