Teil einer Klasse in einer abgeleiteten Klasse umdefinieren

[changlee]

Hallo,

ich habe schon wieder eine Frage. Ich hoffe hiernach kann ich mal längere Zeit problemlos weitermachen. :roll:

Also ich möchte eine Klasse definieren:

Delphi-Quellcode:

TList = class
  private
    fFilename : AnsiString;
    fLength   : integer;
    fItems    : array of TMsgDataSet;
    fLocked   : boolean;
  public
    property Filename : string  read fFilename write fFilename;
    property Length   : integer read fLength   write fLength;
    property Locked   : boolean read fLocked;
    procedure Add(MsgNr:integer; Msg:TIdMessage; MsgSize:cardinal);
    procedure Delete(MsgNr:integer);
    procedure LoadFromHd; virtual;
    procedure SaveToHd; virtual;
    procedure Lock;
    procedure Unlock;
  end;

Diese Klasse möchte ich aber nie direkt benutzen, sondern ich werde weitere Klassen von dieser Ableiten, die bis auf die Methoden "LoadFromHD" und "SafeToHD" sowie den Typ von fItems identisch sind. Die Methoden, die überall gleich sind, möchte ich in der Hauptklasse definieren, z.B. "Delete()". Delete muss auf fItems zugreifen, deshalb muss ich fItems auch in der Hauptklasse definieren. fItems ist immer ein dynamisches Array, aber nicht immer vom Typ TMsgDataSet. Der genaue Typ wird erst in einer abgeleiteten Klasse definiert.

Wie kann ich denn das realisieren?

Viele Grüße
Stefan.

[jfheins]

Du musst für den Item-Typ (der ja anscheinend auch eine Klasse ist) am besten auch so etwas machen: Eine Basisklasse, von der abgeleitet wird. (Kannst auch TObject nehmen)

Oder aber über Interfaces ;)

In D2009 gibt es glaube ich Generics, damit geht das auch.

[changlee]

Hallo jfheins,

mit "Interfaces" kann ich leider gar nichts anfangen. Eine kurze suche hier im Forum hat mich auch erstmal nicht weitergebracht.

Im Moment handelt es sich beim Typ von fItems um records. Wenn ich Klassen dafür verwende, kann ich in der Basisklasse TList einfach die Basisklasse von TItems angeben und in den von TList abgeleiteten Klassen setze ich dann die con TItems abgeleiteten Klassen ein. Richtig?
Ich vermute in dem Fall müsste ich bei TList einen constructor und destructor mit inherited definieren und das erzeugen/vernichten der TItem-Instanz dort ergänzen.
OK, dann werde ich das mal probieren.

Viele Grüße,
Stefan.

[jfheins]

Naja, ich meine das du eine kleine Klasse machst wie folgt:

Delphi-Quellcode:

TBaseItem = class 
  private 
    // Felder
end;

TBaseList = class 
  private 
    fFilename : AnsiString; 
    fLength   : integer; 
    fItems    : array of TBaseItem;
  protected
    procedure setitem(item: TBaseItem, index: Integer); virtual;
    function getitem(index: Integer): TBaseItem; virtual;
    function additem(): TBaseItem; virtual;
// Array-Property evtl.
end;

Und dann später sowas:

Delphi-Quellcode:

TMyItem = class (TBaseItem)
    // Felder
end;

TMyList = class(TBaseList)
  protected
    function getitem(index: Integer): TMyItem; override; // inherited aufrufen und casten
    function additem(): TMyItem; override; // tmyitem erstellen !!
end;

Dann kannst du die sachen mit add und delete schon in der Basisklasse machen, und kannst trotzdem später die richtigen Klassen in das Array reinfüllen. Du musst natürlich immer über die überschriebenen Funktionen gehen (das Array ist ja eh private) damit du auch schon den richtigen Typ casten kannst.

[changlee]

Delphi-Quellcode:

// inherited aufrufen und casten

was meinst du mit casten?


Mir fällt gerade auf: wenn die Listenelemente kein record mehr sind, sondern Klassen, dann kann ich ja im Prinzip gar nichts mehr in der Liste umsortieren (weil Instanz1 := Instanz2 ja nur eine Referenz zuweist, aber keinen Inhalt.)
Dann widerum müsste ich ja auch in der Funktion GetItem irgendwo jedes einzelne Feld der Klasse abfragen und zuweisen.

Delphi-Quellcode:

result := fItems[i]

würde dann ja meines Wissens nicht funktionieren.

Wenn das tatsächlich so ist, dann hätte einen Risen Aufwand und müsste dann auch das umsortieren für jede Liste unterschiedlichen Typs neu implementieren. :shock:

Oder liege ich falsch?

[jfheins]

Zitat:

Zitat von changlee

Delphi-Quellcode:

// inherited aufrufen und casten

was meinst du mit casten?

Naja, da du in der Basisklasse ja sowas machst:

Delphi-Quellcode:

function TBaseList.getitem(index: Integer): TBaseItem;
begin
  Result = fitems[index];
end;

Solltest du in der abgeleiteten Klasse sowas machen:

Delphi-Quellcode:

function TMyList.getitem(index: Integer): TMyItem; // override;
begin
  Result = inherited getitem(index) as TMyItem;
end;

Zitat:

Mir fällt gerade auf: wenn die Listenelemente kein record mehr sind, sondern Klassen, dann kann ich ja im Prinzip gar nichts mehr in der Liste umsortieren (weil Instanz1 := Instanz2 ja nur eine Referenz zuweist, aber keinen Inhalt.)

Natürlich kannst du umsortieren.

Delphi-Quellcode:

temp = getitem(1);
setitem(1, getitem(2));
setitem(2, temp);

Zitat:

Dann widerum müsste ich ja auch in der Funktion GetItem irgendwo jedes einzelne Feld der Klasse abfragen und zuweisen.

Delphi-Quellcode:

result := fItems[i]

würde dann ja meines Wissens nicht funktionieren.

Wenn das tatsächlich so ist, dann hätte einen Risen Aufwand und müsste dann auch das umsortieren für jede Liste unterschiedlichen Typs neu implementieren. :shock:

Oder liege ich falsch?

Wie gesagt, die grundlegenden Operationen kannst du in der Basisklasse einführen und implementieren, und später musst du dann nur noch die Logik implementieren die bei dem neuen Typ dazugekommen ist ;)

[changlee]

Ok, vielen Dank. Dann werde ich das alles mal so ausprobieren.

Gruß
Stefan.