TList ableiten - Pointer -> eigener Pointertyp

[stoxx]

irgendwie habe ich meinen Beitrag wieder editiert anstatt einen neuen Betrag zu erstellen.
(Könnte man die Buttons nicht irgendwie total grell bunt und verschiedenfarbig gestalten ?
ich hatte noch geschrieben: (hier stand noch)

Zitat:

Wenn du sowas als Live-Template realisieren willst, hast du redundanten Code

dass das mich überzeugt hat ! Und wenn ich die Livetemplages von der IDE benutze wird das ja so groß dass man eventuell dafür sowieso eine neue Unit anlegt, also kann man für die Deklaration sowieso eine zweite Unit anlegen. Man muss halt nur aufpassen, dass man nicht zweimal dasselbe Template in einer Unit benutzt.

und nun der Text ..


-----------------

also das mit den IFDEF Konstruktionen scheint eine kompliziertere Sache zu sein, als mein kleines Hirn überblicken kann.
Es ist zwar so, dass meine Variante korrekt zu compilieren geht, aber da funktioniert erstaunlicherweise die Codevervollständigung nicht mehr !
Also das ist irgendwie unlogisch, verstehen tu ich es nicht, na egal.
Man kann es sich aber dennoch vereinfach, wenn man IMMER

{$DEFINE TEMPLATE_DEVELOP} schreibt. Da muss man sich nicht soviel merken !
Außerdem braucht man das nur einmal pro Unit zu deklarieren.
Das macht das ganze noch etwas übersichtlicher.
Das das so ist, ist dennoch unlogisch für mich.
Wenn mal jemand eine typsichere gute alte Liste vom Typ TList benötigt, hier mal der Vollständige Code (Keine Objectliste).

basierend auf der Idee:

http://www.dummzeuch.de/delphi/objec...s/deutsch.html

Hier die Deklaration.

Delphi-Quellcode:

unit u_LabelList;
{$DEFINE TEMPLATE_DEVELOP}

interface

uses
  Sysutils,
  Classes,
  Contnrs,
  StdCtrls;

type

  _TLIST_ITEM = TLabel;
    {$I tmpl_TList.pas}
  TLabelList = class(_TLIST)
  end;



implementation

{$I tmpl_TList.pas}



end.

Hier das TLIST Template

Delphi-Quellcode:

//{$DEFINE TEMPLATE_DEVELOP}
{$IFNDEF TEMPLATE_DEVELOP}
unit tmpl_TList;

interface

// copy these units into the uses clause of every unit using this template
uses
  Sysutils,
  Classes,
  Contnrs;

type
  _TLIST_ITEM = Pointer;
{$ENDIF TEMPLATE_DEVELOP}

{$IFNDEF _TLIST_SECOND_PASS}
type
  _TLIST = class(TLIST)

  protected
    function Get(Const Index: Integer): _TLIST_ITEM;
    procedure Put(Const Index: Integer; Item: _TLIST_ITEM);
  public
    function Add(Const Item: _TLIST_ITEM): Integer;
    function Extract(Const Item: _TLIST_ITEM): _TLIST_ITEM;
    function First: _TLIST_ITEM;
    function IndexOf(Const Item: _TLIST_ITEM): Integer;
    procedure Insert(Const Index: Integer; Item: _TLIST_ITEM);
    function Last: _TLIST_ITEM;
    function Remove(Const Item: _TLIST_ITEM): Integer;
    property Items[Const Index: Integer]: _TLIST_ITEM read Get write Put; default;

  end;

{$ENDIF _TLIST_SECOND_PASS}

{$IFNDEF TEMPLATE_DEVELOP}
implementation
{$DEFINE _TLIST_SECOND_PASS}
{$ENDIF TEMPLATE_DEVELOP}

{$IFDEF _TLIST_SECOND_PASS}

{ _TLIST }



//==============================================================================
function _TLIST.Add(Const Item: _TLIST_ITEM): Integer;
begin
  Result := inherited Add(Pointer(Item));
end;
//==============================================================================
function _TLIST.Extract(Const Item: _TLIST_ITEM): _TLIST_ITEM;
begin
   Result := _TList_ITEM(inherited Extract(Pointer(Item)));
end;
//==============================================================================
function _TLIST.First: _TLIST_ITEM;
begin
   result := _TLIST_ITEM(inherited First);
end;
//==============================================================================
function _TLIST.Get(Const Index: Integer): _TLIST_ITEM;
begin
   result := _TLIST_ITEM(inherited get(Index));
end;
//==============================================================================
function _TLIST.IndexOf(Const Item: _TLIST_ITEM): Integer;
begin
   result := inherited indexof(Pointer(item));
end;
//==============================================================================
procedure _TLIST.Insert(Const Index: Integer; Item: _TLIST_ITEM);
begin
   inherited insert(index, Pointer(item));
end;
//==============================================================================
function _TLIST.Last: _TLIST_ITEM;
begin
  result := _TList_ITEM(inherited last);
end;
//==============================================================================
procedure _TLIST.Put(Const Index: Integer; Item: _TLIST_ITEM);
begin
  inherited put(index, Pointer(item));
end;
//==============================================================================
function _TLIST.Remove(Const Item: _TLIST_ITEM): Integer;
begin
  result := inherited remove(Pointer(item));
end;
//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================



{$WARNINGS off}
{$IFNDEF TEMPLATE_DEVELOP}
end.
{$ENDIF TEMPLATE_DEVELOP}
{$ENDIF _TLIST_SECOND_PASS}
{$DEFINE _TLIST_SECOND_PASS}

Wenn man nicht vor hat, die Unit weiterzuentwickeln, dann kann man

{$DEFINE TEMPLATE_DEVELOP} auch ganz oben in die Unit schreiben und spart sich das beim deklarieren von einem Nachfahr dieser Liste.
Dann geht aber wie gesagt die Codevervollständigung nicht mehr.



und hier der Beweis dass es eine Typsichere Liste ist