wie verschiedene Objekttypen sinnvoll speichern?

[martin28]

Hi.

@uligerhardt

Die Variante mit array[0..3] of TFahrzeug funktioniert ganz gut. Ich kann die einzelnen abgeleiteten Klassen dort ablegen. Damit ergibt sich für mich jetzt ein weiteres Problem:

Nehmen wir an, das TFahrzeug eine Funktion vom Typ

Code:

function tanken():byte; virtual; abstract;

besitzt.

Für TAuto und TMotorrad nutze ich diese Funktion dann folgendermaßen

Code:

function tanken():byte; reintroduce;

Für die Klasse TLkw möchte ich aber

Code:

function tanken(adblue:boolean):byte; reintroduce;

nutzen.

Wenn ich die Objekte einzeln erzeugen würde, könnte ich die Funktion auch problemlos nutzen

Code:

var golf:TAuto;
var laster:TLkw;
begin
   golf := TAuto.create;
   golf.tanken()
   laster := TLkw.create;
   laster.tanken(TRUE);

Da ich aber jetzt die Deklaration über

Code:

var fahrzeugpool : array[0..3] of TFahrzeug;

und

Code:

   fahrzeugpool[0] := TAuto.create;
   fahrzeugpool[1] := TLkw.create;

nutze, bekomme ich bei

Code:

   adblue_tanken := TRUE;
   fahrzeugpool[1].tanken(adblue_tanken);

ein Compilerfehler. (Too many actual parameters)
Ist ja auch klar, da in der TFahrzeug Funktion tanken() kein weiterer Parameter vorhanden ist.

Wie kann ich dennoch auf die tanken-Funktion vom LKW mit dem Parameter zugreifen?

Grüße,

Martin

PS. habe jetzt alle Namen zur leichteren Lesbarkeit angepasst

[uligerhardt]

Zitat von martin28:

Für TAuto und TMotorrad nutze ich diese Funktion dann folgendermaßen

Code:

function tanken():byte; reintroduce;

Vermutlich willst du override statt reintroduce . Sonst muss die Methode in der Basisklasse ja nicht als virtuell deklariert sein.

Zitat von martin28:

Für die Klasse TLkw möchte ich aber

Code:

function tanken(adblue:boolean):byte; reintroduce;

nutzen.

Wenn ich die Objekte einzeln erzeugen würde, könnte ich die Funktion auch problemlos nutzen

Code:

var golf:TAuto;
var laster:TLkw;
begin
   golf := TAuto.create;
   golf.tanken()
   laster := TLkw.create;
   laster.tanken(TRUE);

Da ich aber jetzt die Deklaration über

Code:

var fahrzeugpool : array[0..3] of TFahrzeug;

und

Code:

   fahrzeugpool[0] := TAuto.create;
   fahrzeugpool[1] := TLkw.create;

nutze, bekomme ich bei

Code:

   adblue_tanken := TRUE;
   fahrzeugpool[1].tanken(adblue_tanken);

ein Compilerfehler. (Too many actual parameters)
Ist ja auch klar, da in der TFahrzeug Funktion tanken() kein weiterer Parameter vorhanden ist.

Wie kann ich dennoch auf die tanken-Funktion vom LKW mit dem Parameter zugreifen?

Entweder casten:
TLkw(fahrzeugpool[1]).tanken(adblue_tanken); Oder du nutzt eine Zwischen-Variable:

Delphi-Quellcode:

var
  laster: TLkw;
begin
 laster := TLkw.Create;
 fahrzeugpool[1] := laster;
 laster.tanken(True);

Zitat von martin28:

PS. habe jetzt alle Namen zur leichteren Lesbarkeit angepasst

Du wirst mir noch dankbar sein.

[Bummi]

TLKW(fahrzeugpool[1]).tanken(adblue_tanken); Einfacher wäre es wenn Du tanken zwar virtual aber nicht abstract deklarierst.

Delphi-Quellcode:

 TFahrzeug=Class
    function tanken():byte; virtual;
  End;
  TLKW=Class(TFahrzeug)
    function tanken():byte; override;
  end;

//__________


{ TFahrzeug }

function TFahrzeug.tanken: byte;
begin
  Showmessage('Fahrzeug tanken')
end;

{ TLKW }

function TLKW.tanken: byte;
begin
   Showmessage('LKW tanken;')
end;

procedure TForm3.Button1Click(Sender: TObject);
var
 f:TFahrzeug;  //<<*
begin
   f:=TLKW.Create; //<<*
   f.tanken;       // "LKW tanken" 
end;

[QuickAndDirty]

Wäre für ihn nicht ein Record mit case am besten?

die andere Möglichkeit wäre.
"Tanken" in beiden Versionen überladen in die Basisklasse aufzunehmen.

[Sir Rufo]

Eine andere Möglichkeit wäre eine von der Basisklasse eine weitere Basisklasse zu erstellen mit der geänderten Methode und die konkreten davon ableiten.

Für die Verarbeitung der einzelnen Instanzen würde sich dann das Visitor-Pattern empfehlen, wo auf diese Abweichungen reagiert werden kann.

[sx2008]

Diese "tanken"-Methode ist schon in der Basisklasse kaputt.
Beim Tanken gibt es zwei wichtige Parameter: die Menge und die Art des Sprits.

Delphi-Quellcode:

TSpritSorte = (sDefault{=Spritsorte die ein Fahrzeug normalerweise benötigt}, 
   sBenzin, sDieselPkw, sSuperE5, sSuperE10);
TFahrzeug=Class
  procedure tanken(liter:Currency; sorte:TSpritSorte); virtual;
End;

Wenn man Klassen ableitet, dann darf man nicht die Signatur von virtuellen Methoden in abgeleiteten Klassen ändern.
Man muss virtuelle Methoden so anlegen, dass sie immer passen.

Falls es trotzdem klemmt liegt das daran, das ein Fahrzeug nicht zwingend betankt werden muss.
Ein Fahrrad ist z.B. auch ein Fahrzeug; braucht aber keinen Sprit.
Beim LKW ist das Nachfüllen von Harnstoff (AdBlue) eher ein Wartungsvorgang als ein Tankvorgang (so wie man Motoröl und Wischwasser nachfüllt).

siehe auch: Kreis-Ellipse-Problem

[Sir Rufo]

Das sehe ich nicht so, ich würde die Methode tanken eher so aufbauen, dass ich übergebe, wo das Fahrzeug tanken soll.

Welchen Treibstoff und welche Menge, dass weiß das Fahrzeug selber (volltanken oder nur soviel um das nächste Ziel zu erreichen) und kann dann die "Tankstelle" fragen, ob es den Treibstoff xy dort in ausreichender Menge noch gibt.