Array of TStringList erzeugen

[malo]

Hi!

Ich will für meinen Parser ein StringList-Array haben. Dazu hab ich schön ein array of TStrings deklariert. Jetzt will ich das Array mit dem Index 0 erzeugen. Bei folgendem Code denkt der Compiler aber, ich will auf einen String meiner StringListe zugreifen:

Delphi-Quellcode:

Tokens[0] := TStringList.Create

Wie kann ich denn aber sonst mit einem Stringlisten-array arbeiten? :?

[malo]

:oops: Falscher Alarm, hatte zum Probieren das "array of" weggelassen :duck:

Allerdings wird eine Exception ausgelöst. Einmal die beiden einzigen Prozeduren in meinem Code:

Delphi-Quellcode:

constructor TTokenizer.Create;
begin
  Tokens[0] := TStringList.Create;
end;

procedure TForm2.FormCreate(Sender: TObject);
begin
  Tokenizer := TTokenizer.Create;
end;

Und einmal die Klassendeklaration von TTokenizer und var-Abschnitt:

Delphi-Quellcode:

type
  TTokenizer = class(TObject)
    private

    public
      Tokens: array of TStrings;

      constructor Create;
    end;

var
  Form2: TForm2;
  Tokenizer: TTokenizer;
  Parse: TParse;

Das bringt mir eine Speicher-Zugriffsverletzung... :?

[Nils_13]

Hi,

der Code läuft zwar nicht könnte dir aber evtl. weiterhelfen

Delphi-Quellcode:

  Symbol = class(TObject)
  procedure Add( aStr: string; aID: integer); overload;
  private
    StringList: TStringList;
    FList      : TList;
  end;

  Lexer = class(TObject)
  constructor Create;
  private
    FFileName   : string;
    FData       : string;
    FPos        : integer;
    Table      : Symbol;
  end;

{ ... }

// Parser
procedure Symbol.Add(aStr: string; aID: integer);
begin
StringList.Add(AnsiLowerCase(aStr));
FList.Add(Pointer(aID));
end;

// Lexer
constructor Lexer.Create;
begin
  Table := Symbol.Create;
  with Table do
  begin
    Add( s_tok_Programm,       c_tok_Programm );
    Add( s_tok_Unit,           c_tok_Unit);
    Add( s_tok_Interface,      c_tok_Interface);
    Add( s_tok_Implementation, c_tok_Implementation);
    Add( s_tok_Begin,          c_tok_Begin);
    Add( s_tok_End,            c_tok_End);
  end;
end;

Der Codeschnipsel schon, du musst dir halt noch gedanken darüber machen wie du den Parser aufrufst.

[malo]

@Nils: :gruebel: Ich wüsste nicht, wie mir der Code helfen soll. Ganz nebenbei gehts mir grade nur um die Erzeugung des TStringList-Arrays ;)

Gedanken über Parser kommen später.

[Christian Seehase]

Moin Malo,

ich denke mal, der Fehler liegt hier:

Delphi-Quellcode:

Tokens: array of TStrings;

TStrings ist eine abstrakte Klasse, von der man keine Instanzen bilden sollte.
Nimm TStringList.

[alcaeus]

Zitat:

Zitat von Christian Seehase

Moin Malo,

ich denke mal, der Fehler liegt hier:

Delphi-Quellcode:

Tokens: array of TStrings;

TStrings ist eine abstrakte Klasse, von der man keine Instanzen bilden sollte.
Nimm TStringList.

Nein. Er erstellt keine Instanz von TStrings, sondern von TStringList. Allerdings kann man aufgrund des OOP-Prinzips einer TStrings-Variable auch ein TStringList-Objekt zuweisen.
Aber einen versuch waere es wert.

Greetz
alcaeus

[malo]

Zitat:

Zitat von Christian Seehase

Moin Malo,

ich denke mal, der Fehler liegt hier:

Delphi-Quellcode:

Tokens: array of TStrings;

TStrings ist eine abstrakte Klasse, von der man keine Instanzen bilden sollte.
Nimm TStringList.

Wie alcaeus bereits sagte, erzeuge ich eine Instanz von TStringList. Funktioniert aber trotzdem nicht... :(

//edit: Es liegt aber am Array. Wenn ich eine einfache Instanz von TStringList erzeuge, funktioniert es wunderbar ;)

[Christian Seehase]

Moin Andreas,

stimmt auch wieder, die Stelle hatte ich überlesen.

@malo:
es könnte bei einem dynamischen Array allerdings nicht schaden, wenn Du vor der Benutzung erst einmal Speicher reservierst (setlength). ;-)

[malo]

:wall: Hab ich auch grade rausgefunden. Hab mich nämlich an ein ähnliches Array-Problem vorher erinnert... funktioniert jetzt :)

[Muetze1]

Moin!

Und warum nicht einfacher mit einer TObjectList aus der Contnrs.pas anstatt einem dynamischen Arrays?

MfG
Muetze1

[malo]

Zitat:

Zitat von Muetze1

Moin!

Und warum nicht einfacher mit einer TObjectList aus der Contnrs.pas anstatt einem dynamischen Arrays?

MfG
Muetze1

Vielleicht, weil ich mich damit nicht auskenne?

Das größte Verständnisproblem bei TList und TObjectList ist bei mir jedoch, wie man einen Typen festlegen kann in einer TList oder TObjectList ;)

Da hab ich nämlich noch nichts zu gefunden :oops:

[Kedariodakon]

Du machst ne ableitung davon und machst für jede Methode ne neue mit deiner Klasse, da die ja von TObject abgeleitet ist, hast du damit kein Problem... :gruebel:

[Kroko1999]

Delphi-Quellcode:

TObjectList.Items[Index: Integer]: TObject;

und mittels TypeCast

Delphi-Quellcode:

TStringList(TObjectList.Items[Index]);

ich verwende viel TObjectList, dann muss ich mich nicht um das Freigeben der Objecte kümmern

Delphi-Quellcode:

property OwnsObjects: Boolean;

[maximov]

Zitat:

Zitat von malo

Zitat:

Zitat von Muetze1

Moin!

Und warum nicht einfacher mit einer TObjectList aus der Contnrs.pas anstatt einem dynamischen Arrays?

MfG
Muetze1

Vielleicht, weil ich mich damit nicht auskenne?

Das größte Verständnisproblem bei TList und TObjectList ist bei mir jedoch, wie man einen Typen festlegen kann in einer TList oder TObjectList ;)

Da hab ich nämlich noch nichts zu gefunden :oops:

Was gibt es denn auszukennen. Die methoden der listen sind selbbeschreibend. Und das die typen sind halt nicht festgelegt, da TObjectList alle TObjects aufnimmt, die es bekommt. Wenn du nun auf die objekte der liste zugreifst, dann musst du ganz normal casten:

Delphi-Quellcode:

var
  l:TObjectList;
...
  l.add(DeinObj);
...
  deinAnderesObj := l[0] as TDeineKlasse;

:-D Und schon hast du keinen stress mit irgendwelchen blöden pseudo-dynamischen arrays!

[Kedariodakon]

Zitat:

Zitat von malo

Vielleicht, weil ich mich damit nicht auskenne?

Das größte Verständnisproblem bei TList und TObjectList ist bei mir jedoch, wie man einen Typen festlegen kann in einer TList oder TObjectList ;)

Da hab ich nämlich noch nichts zu gefunden :oops:

So da hast mal die wichtigsten:

Delphi-Quellcode:

Unit MaloUtils;

Interface

Uses   Classes, SysUtils, Contnrs;

Type
   TMaloObj   =   Class      //   Dein Obj halt...
   Private
      { Private-Deklarationen }
   Public
      { Public-Deklarationen }
   End;

Type
   TMaloObjList   =   Class( TObjectList )
   Private
      { Private-Deklarationen }
      Function GetItems( Index: Integer ):   TMaloObj;
   Public
      { Public-Deklarationen }
      Procedure   Insert( Const Index: Integer; Const MaloObj: TMaloObj );
      Function   Add( Const MaloObj: TMaloObj ): Integer;
      Property   Items[ Index: Integer ]: TMaloObj Read GetItems;   Default;
   End;

Implementation

{ TMaloObjList }

Function TMaloObjList.Add( Const MaloObj: TMaloObj ): Integer;
Begin
   Result   := Inherited Add( MaloObj );
End;

Function TMaloObjList.GetItems( Index: Integer ): TMaloObj;
Begin
   Result   := Inherited Items[ Index ] As TMaloObj;
End;

Procedure TMaloObjList.Insert( Const Index: Integer; Const MaloObj: TMaloObj );
Begin
   Inherited Insert( Index, MaloObj );
End;

End.

Den Rest kannst dir ja selbst machen ^^
Oder nimst Casts wie nen Blöder ^^
Meiner einer schreibt lieber ne Listen Klasse für, ist später lesbarer und schöner zu Warten :zwinker:

Bye

[maximov]

@Kedariodakon: Dafür kann man lieber eins von diesen tollen delphi-pseudo-templates machen, dann hat man mit vier zeilen code eine solche klasse generisch erzeugt und kann sich den wirklich wichtigen sachen widmen. -> siehe dpCollection template!

[malo]

Irgendwie kapiere ich jetzt immer noch nichts... mit arrays geht das so:

Delphi-Quellcode:

type
  TMyType = string;

var: MeinArray: array of TMyType;
begin
  TMyType[0] := 'Hallo Welt';
end;

Und mit Klassen muss ich irgendwelche Umwege über irgendwelche Klassen gehen? Wo ist da der Vorteil? Ich sehe da nur unnötige Arbeit drin.

[Kedariodakon]

Zitat:

Zitat von malo

Irgendwie kapiere ich jetzt immer noch nichts... mit arrays geht das so:

Delphi-Quellcode:

type
  TMyType = string;

var: MeinArray: array of TMyType;
begin
  TMyType[0] := 'Hallo Welt';
end;

Und mit Klassen muss ich irgendwelche Umwege über irgendwelche Klassen gehen? Wo ist da der Vorteil? Ich sehe da nur unnötige Arbeit drin.

Man kann sie einfacher sortieren...
Man kann sie einfacher erweitern...
Man kann einfacher Werte hinzufügen ( irgendwo irgendwan ^^ )...
Man kann einfacher Werte herrauslöschen ( irgendwo irgendwan ^^ )...
...

Bye

[alcaeus]

Hallo malo,

das hat den Vorteil dass du ein Element aus dem Mitte der Liste loeschen kannst, ohne nachher das halbe Array verschieben musst. Das wird im Hintergrund fuer dich erledigt, und du kannst dich auf die wichtigen Dinge des Lebens konzentrieren :zwinker:
Aber wie maximov gesagt hat, ich kann auch nur die templated Collections empfehlen. Bei einem Blick drauf fuehlt man sich irgendwie frisch verliebt :love: :lol:

Greetz
alcaeus

[maximov]

Zitat:

Zitat von malo

Irgendwie kapiere ich jetzt immer noch nichts... mit arrays geht das so:

Delphi-Quellcode:

type
  TMyType = string;

var: MeinArray: array of TMyType;
begin
  TMyType[0] := 'Hallo Welt';
end;

Und mit Klassen muss ich irgendwelche Umwege über irgendwelche Klassen gehen? Wo ist da der Vorteil? Ich sehe da nur unnötige Arbeit drin.

mal ehrlich! Schon das beispiel ist grob falsch, denn du hast vergessen das array zu vergrössern. Das zeigt auch schon warum eine klasse nicht so falsch wäre: Sie nimmt uns extrem viel arbeit ab, da sie sich selbst um solche sache kümmert und uns damit nicht belästigt. Was ist denn so schlimm an einer klasse?

[Kedariodakon]

Zitat:

Zitat von maximov

@Kedariodakon: Dafür kann man lieber eins von diesen tollen delphi-pseudo-templates machen, dann hat man mit vier zeilen code eine solche klasse generisch erzeugt und kann sich den wirklich wichtigen sachen widmen. -> siehe dpCollection template!

Ok die schau ich mir mal an ^^

[malo]

Zitat:

Zitat von maximov

Zitat:

Zitat von malo

Irgendwie kapiere ich jetzt immer noch nichts... mit arrays geht das so:

Delphi-Quellcode:

type
  TMyType = string;

var: MeinArray: array of TMyType;
begin
  TMyType[0] := 'Hallo Welt';
end;

Und mit Klassen muss ich irgendwelche Umwege über irgendwelche Klassen gehen? Wo ist da der Vorteil? Ich sehe da nur unnötige Arbeit drin.

mal ehrlich! Schon das beispiel ist grob falsch, denn du hast vergessen das array zu vergrössern. Das zeigt auch schon warum eine klasse nicht so falsch wäre: Sie nimmt uns extrem viel arbeit ab, da sie sich selbst um solche sache kümmert und uns damit nicht belästigt. Was ist denn so schlimm an einer klasse?

Eine Klasse erhöht extrem die Tipparbeit, finde ich. "Einfach mal so" eine Klasse für etwas zu schreiben finde ich einfach nur nervig. In diesem Beispiel würde ich es jedoch evtl. sogar machen, das Problem liegt aber darin, dass ich einfach nicht verstehe, wie man obiges Beispiel von mir (evtl. dann mit SetLength) mit TList oder TObjectList lösen könnte. Die Klasse zu erzeugen ist nicht das Problem. Aber wie lege ich einen Typ darin fest? Ich hab zwar auch schon ein paar Codeschnipsel bekommen, für die ich auch sehr dankbar bin, aber ich habe immer noch nichts verstanden :roll:

[Kroko1999]

Delphi-Quellcode:

type
  TMyClass = class(TObjectList)
    private
    function GetItem(AIndex: Integer): TStringList;

    protected

    public
      procedure NewClass;
      property Items[AIndex: Integer]: TStringList read GetItem;
  end;

function TMyClass.GetItem(AIndex: Integer): TStringList;
begin
  if AIndex<Count then Result := TStringlist(inherited Items[AIndex])
                  else Result := nil;
end;

procedure TMyClass.NewClass;
begin
  Add (TStringList.Create);
end;

procedure Test; // Vor.: MyClass ist created
begin
  myClass.NewClass;
  MyClass.Items[0].Add ('Hallo');
end;

[Kedariodakon]

Öhm???
Also von vorn:
Eine TObjectList ist eine Liste!
Dieser Liste können Objecte vom Typ TObject hinzugefügt werden.
Da alle Klassen von TObject Abgeleitet sind, kannst du jede Klasse da einfach reintun, egal ob das eine TStrings, eine TStringlist oder ein TButton oder Ein TLabel oder oder oder... ist, dies alles past in eine einzige Inztanz...

Hinzugefügt werden sie einfach mit Add...

So das raushollen ist ein wenig schwieriger, gerade dann, wenn man TLabels, TButtons, TForms und Co darin hat, aber dafür gibts ja abfragen ala

Delphi-Quellcode:

 If ... Is TButton Then ... := As TButton;

Eigendlich ist das einfachste OOP ...

Schau doch einfach nochmal eine Seite zurück auf mein Beispiel, mit dem TMaloObj und der TMaloObjList, da ist TMaloObj ein Object (irgendeins) und TMaloObjList ist die Liste zu diesem Object...

Wenn du die paar ZEilen dort vom Beispiel verstanden hast, kannst du dir ja mal die dpCollection anschauen, denn es bringt nach meiner Meinung nix, was zu benutzen, was man nicht versteht...

Bye

[maximov]

Zitat:

Zitat von malo

...
Eine Klasse erhöht extrem die Tipparbeit, finde ich. "Einfach mal so" eine Klasse für etwas zu schreiben finde ich einfach nur nervig. In diesem Beispiel würde ich es jedoch evtl. sogar machen, das Problem liegt aber darin, dass ich einfach nicht verstehe, wie man obiges Beispiel von mir (evtl. dann mit SetLength) mit TList oder TObjectList lösen könnte. Die Klasse zu erzeugen ist nicht das Problem. Aber wie lege ich einen Typ darin fest? Ich hab zwar auch schon ein paar Codeschnipsel bekommen, für die ich auch sehr dankbar bin, aber ich habe immer noch nichts verstanden :roll:

Die tipparbeit ist nicht der kritische faktor! Du kannst 100 stunden tipparbeit einsparen, wenn du dir eine stunde mal gedanken machen würdest. Alles was du brauchst ist das, was hier im thread gesagt wurde und die bereitschaft es verstehen zu wollen.


@Kedariodakon: Es geht nicht um die dpCollection, sondern eher um die technik des templates. Damit kann man nämlich mit 4 zeilen code eine komplette typisierte objektliste erzeugen.

[Kedariodakon]

Zitat:

Zitat von maximov

@Kedariodakon: Es geht nicht um die dpCollection, sondern eher um die technik des templates. Damit kann man nämlich mit 4 zeilen code eine komplette typisierte objektliste erzeugen.

das ist schon klar, nur kann er nicht mal selber eine machen, wie soll das den dann mit der handhabung der dpCollection aussehen? :gruebel:


Bye

[Robert_G]

Zitat:

Zitat von Kedariodakon

Zitat:

Zitat von maximov

@Kedariodakon: Es geht nicht um die dpCollection, sondern eher um die technik des templates. Damit kann man nämlich mit 4 zeilen code eine komplette typisierte objektliste erzeugen.

das ist schon klar, nur kann er nicht mal selber eine machen, wie soll das den dann mit der handhabung der dpCollection aussehen? :gruebel:

Ein Collection Descendant wäre hier doch total ungeeignet.
TCollection schluckt nur TCollectionItem-Nachfahren!
Will man Objekte verwalten wäre eine TObjectList ein passabler Anfang. ;)

Und wen so ein Template interessiert...
Nix einfacher als das. ;)

• Du nimmst wie ich eine bestehende, eingestaubte Objectlist Ableitung
• Eine Runde Search'nReplace um die Bezeichner so scheußlich wie möglich zu kriegen. (Sie sollten ja keineswegs mit "Real Life" Bezeichnern kollidieren. ;)
• ein bisschen bedingte Kompilierung (Die Einfachheit des Delphis Compilers ist hier mal ein Vorteil :zwinker: )
• ->voilá

Nix weltbewegendes, auf kein Fall etwas schönes.... aber tierisch praktisch :mrgreen:

Delphi-Quellcode:

{$IFNDEF TYPED_OBJECT_LIST_TEMPLATE}
unit TypedObjectList_template;

interface
uses
   Contnrs;

type _OBJECT_LIST_ITEM_ = TObject;

{$ENDIF TYPED_OBJECT_LIST_TEMPLATE}

{$IFNDEF TYPED_OBJECT_LIST_TEMPLATE_SECOND_PASS}

// Jedi's include to evaluate compiler version...
{$INCLUDE Jedi.inc}


type
   _OBJECT_LIST_IENUM_ = interface;
   _OBJECT_LIST_ENUM_ = class;
   _OBJECT_LIST_ = class(TObjectList)
   protected
      function  GetItem(Index: Integer): _OBJECT_LIST_ITEM_; virtual;
      procedure SetItem(Index: Integer; const Value: _OBJECT_LIST_ITEM_); virtual;
   public
      function Add(aObject: _OBJECT_LIST_ITEM_): Integer; reintroduce; virtual;
      function Extract(Item: _OBJECT_LIST_ITEM_): _OBJECT_LIST_ITEM_; reintroduce; virtual;
      function Remove(aObject: _OBJECT_LIST_ITEM_): Integer; reintroduce; virtual;
      function IndexOf(aObject: _OBJECT_LIST_ITEM_): Integer; reintroduce; virtual;
      procedure Insert(Index: Integer; aObject: _OBJECT_LIST_ITEM_); reintroduce; virtual;
      function First: _OBJECT_LIST_ITEM_; reintroduce;
      function Last: _OBJECT_LIST_ITEM_; reintroduce;
      property Items[Index: Integer]: _OBJECT_LIST_ITEM_
         read  GetItem
         write SetItem; default;

      function GetIEnumerator(): _OBJECT_LIST_IENUM_;
{$IFDEF COMPILER9_UP}
      function GetEnumerator(): _OBJECT_LIST_ENUM_;
{$ENDIF COMPILER9_UP}
   end;

   _OBJECT_LIST_IENUM_ = interface
      function MoveNext: Boolean;
      function GetCurrent: _OBJECT_LIST_ITEM_;
      property Current: _OBJECT_LIST_ITEM_ read GetCurrent;
   end;

   _OBJECT_LIST_ENUM_ = class(TInterfacedObject, _OBJECT_LIST_IENUM_)
   private
      fCollection: _OBJECT_LIST_;
      fIndex: Integer;
      constructor Create(List: _OBJECT_LIST_);
   public
      function MoveNext: Boolean;
      function GetCurrent: _OBJECT_LIST_ITEM_;
      property Current: _OBJECT_LIST_ITEM_ read GetCurrent;
   end;


{$ENDIF TYPED_OBJECT_LIST_TEMPLATE_SECOND_PASS}

{$IFNDEF TYPED_OBJECT_LIST_TEMPLATE}
implementation

{$DEFINE TYPED_OBJECT_LIST_TEMPLATE_SECOND_PASS}
{$ENDIF TYPED_OBJECT_LIST_TEMPLATE}

{$IFDEF TYPED_OBJECT_LIST_TEMPLATE_SECOND_PASS}

{ _OBJECT_LIST_ITEM_ }

function _OBJECT_LIST_.Add(aObject: _OBJECT_LIST_ITEM_): Integer;
begin
   RESULT := inherited Add(aObject);
end;

function _OBJECT_LIST_.Extract(Item: _OBJECT_LIST_ITEM_): _OBJECT_LIST_ITEM_;
begin
   RESULT := _OBJECT_LIST_ITEM_(inherited Extract(Item));
end;

function _OBJECT_LIST_.First: _OBJECT_LIST_ITEM_;
begin
   RESULT := _OBJECT_LIST_ITEM_(inherited First());
end;

function _OBJECT_LIST_.GetItem(Index: Integer): _OBJECT_LIST_ITEM_;
begin
   RESULT := _OBJECT_LIST_ITEM_(inherited Items[Index]);
end;

function _OBJECT_LIST_.IndexOf(aObject: _OBJECT_LIST_ITEM_): Integer;
begin
   RESULT := inherited IndexOf(aObject);
end;

procedure _OBJECT_LIST_.Insert(Index: Integer; aObject: _OBJECT_LIST_ITEM_);
begin
   inherited Insert(Index, aObject);
end;

function _OBJECT_LIST_.Last: _OBJECT_LIST_ITEM_;
begin
   RESULT := _OBJECT_LIST_ITEM_(inherited Last());
end;

function _OBJECT_LIST_.Remove(aObject: _OBJECT_LIST_ITEM_): Integer;
begin
   RESULT := inherited Remove(aObject);
end;

procedure _OBJECT_LIST_.SetItem(Index: Integer;   const Value: _OBJECT_LIST_ITEM_);
begin
   inherited Items[Index] := Value;
end;

{$IFDEF COMPILER9_UP}

function _OBJECT_LIST_.GetEnumerator: _OBJECT_LIST_ENUM_;
begin
  RESULT := _OBJECT_LIST_ENUM_.Create(self);
end;

function _OBJECT_LIST_.GetIEnumerator: _OBJECT_LIST_IENUM_;
begin
   RESULT := GetEnumerator();
end;

{$ELSE}

function _OBJECT_LIST_.GetIEnumerator: _OBJECT_LIST_IENUM_;
begin
   RESULT := _OBJECT_LIST_ENUM_.Create(self);
end;

{$ENDIF COMPILER9_UP}

constructor _OBJECT_LIST_ENUM_.Create(List: _OBJECT_LIST_);
begin
  fIndex := -1;
  fCollection := List;
end;

function _OBJECT_LIST_ENUM_.GetCurrent: _OBJECT_LIST_ITEM_;
begin
  RESULT := fCollection.GetItem(fIndex);
end;

function _OBJECT_LIST_ENUM_.MoveNext: Boolean;
begin
  inc(fIndex);
   RESULT := (fIndex > -1) and (fIndex < fCollection.Count);
end;


{$WARNINGS off}
{$IFNDEF TYPED_OBJECT_LIST_TEMPLATE}
end.
{$ENDIF TYPED_OBJECT_LIST_TEMPLATE}
{$ENDIF TYPED_OBJECT_LIST_TEMPLATE_SECOND_PASS}
{$DEFINE TYPED_OBJECT_LIST_TEMPLATE_SECOND_PASS}

Die Verwendung ist denkbar einfach (die 4 Zeilen, von denen maximov sprach ;) )

Delphi-Quellcode:

interface
uses Contnrs; /// <- wichtig!

type
   TSomeClass = class
   private
      fSomeProperty: Integer;
   public
      property SomeProperty: Integer
         read fSomeProperty
         write fSomeProperty;
   end;


{$DEFINE TYPED_OBJECT_LIST_TEMPLATE}
type _OBJECT_LIST_ITEM_ = TSomeClass;
{$INCLUDE TypedObjectList_template.pas}
   TSomeClassList = _OBJECT_LIST_;
implementation
{$INCLUDE TypedObjectList_template.pas}
end.

direkt angewand könnte man vor D2005 so durch sie laufen:

Delphi-Quellcode:

   with SomeClassList.GetIEnumerator() do
      while MoveNext() do
         WriteLn(Current.SomeProperty);

In D2005 geht nun auch gleich das hier:

Delphi-Quellcode:

var
   SomeInstance :TSomeClass;
begin
   for SomeInstance in SomeClassList do
      WriteLn(SomeInstance.SomeProperty);

[maximov]

Wenn das nicht einfach ist - abgesehen davon, dass es hässlich aussieht - dann weiss ich auch nicht!

[Robert_G]

Zitat:

Zitat von maximov

Wenn das nicht einfach ist - abgesehen davon, dass es hässlich aussieht - dann weiss ich auch nicht!

Aber das "hässlich" ist kein wirkliches Problem... Schließlich muss man sich den Apettiszügler so schnell nicht mehr ankieken. :mrgreen:
Nur noch benutzen! :)