wie verschiedene Objekttypen sinnvoll speichern?

[martin28]

Hi alle zusammen.

Ich grüble schon seit einigen Tagen über folgendes Problem:
Bsp.
Klasse C_Fahrzeug.
Abgeleitet sind C_Motorrad, C_Auto und C_LKW.
Der Benutzer kann als Beispiel mit 4 Buttons Objekte der abgeleiteten Klassen erzeugen und löschen. Dabei hat er aber die Auswahl welchen der 3 er erzeugen will.

Meine Frage: Wie kann ich dies sinnvoll speichern? Zur Zeit nutze ich folgende Konstruktion:

Delphi-Quellcode:

var buttonzuordnung : array[0..3] of record
       typ : integer;
       autotyp : c_auto;
       motorradtyp : c_motorrad;
       lkwtyp : c_lkw;
    end;

Somit muss ich jedesmal, wenn der Benutzer einen anderen Typ wählt :
- die Auswahl in typ speichern
- vorher altes objekt schließen
- zum Schluss ein neues Objekt vom neuen Typ erstellen.

Ich meine, bei diesen 3 Klassen ist es noch erträglich. Wenn aber 10 oder 20 abgeleitete Klassen zur Verfügung stehen, wird es schnell unübersichtlich.

Hat einer einen Tipp für mich ?

Grüße,

Martin

[Bernhard Geyer]

Wie wäre es mit XML?

[uligerhardt]

Mit "Speichern" meinst du jetzt nicht "Objekt in eine Datei auf der Festplatte speichern", oder hab ich dich falsch verstanden?

Ich glaube, du suchst var buttonzuordnung : array[0..3] of C_Fahrzeug; und statt typ sowas wie if buttonzuordnung[1] is c_auto then ... . Statt der is -Konstruktion wären virtuelle Methoden natürlich wesentlich schöner.

Das mit array[0..3] of C_Fahrzeug; funktioniert, weil du Referenzen auf Objekte einer abgeleiteten Klasse einer Basisklassenreferenz zuweisen kannst, also z.B.

Delphi-Quellcode:

var
  fahrzeug: C_Fahrzeug;
begin
  fahrzeug := C_Auto.Create;
end;

Ohne das würde die ganze OO nicht funktionieren.

BTW: Tu dir und uns den Gefallen und benenn deine Klassen Delphi-konform: TFahrzeug, TAuto etc.

[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.