Compiler stoppt bei Klassenzuweisungen

[niceday]

hallo !

gibt es eine möglichkeit die sehr strenge typüberwachung des
delphi-compiler ein wenig zu verringern ??

ich habe klasse "Auto" und klasse "LKW"; beides Nachfolger von Klasse
"Fahrzeug". Wenn ich später im Programm eine Variable "Fahrzeug"
deklariere und dieser ein "Auto" zuweisen möchte compiliert delphi nicht
duch (Inkompatible Typen). ich muss jedesmal ein typecasting durchführen,
was mir ziemlich auf die nerven geht.

beispiel:

type
TFahrzeug = class(TObject)
end

TAuto = class(TFahrzeug)
end

var f1:TFahrzeug;
f2:TAuto;
begin
f2 := TAuto.Create;
f1 := f2; // hier bleibt delphi stehen
end;

danke...

adi

[niceday]

sorry !!! <br>

das beispiel war natürlich murks.<br>

so mein' ich das:<br>

type TFahrzeug = class(TObject) end <br>

TAuto = class(TFahrzeug) <br>
end <br>

TLKW = class(TFahrzeug) <br>
end <br>

var f1:TFahrzeug; <br>
f2:TAuto; <br>
f3:TLkw;<br>
begin <br>
f2 := TAuto.Create; <br>
f3 := f2; // hier bleibt delphi stehen <br>
end; <br>

ad

[Hagen Reddmann]

Hi Adnan

Du wirst nicht um einen TypeCast drumrumkommen.
Beide Typen TLKW und TAuto sind NICHT kompatibel, aber zum
Muttertyp TFahrzeug wiederum Zuweisungkompatibel.

<pre>

var
A: TAuto;
L: TLKW;
F: TFahrzeug;
begin
A := TAuto.Create;
L := TLKW.Create;

// folgendes ist ok
F := A;
F := L;

A := L as TAuto; // as überprüft den Typ
A := TAuto(L); // radikales Typcast OHNE Überprüfung
A := F as TAuto;

// folgendes nicht

A := L;
L := A;
A := F;
L := F;

end;

</pre>

D.h. alle Klassen sind zum gemeinsammen Vorfahrtyp compatibel. Eine Variable vom gemeinsammen Vorfahrtyp kann also verschiedene Nachfahrentypen beinhalten. Diese Eigenschaft der Objecte nennt man "Polymorphie" der Typen.

Daraus folgt: Man sollte beim Klassendesign ALLE wesentlichen und wichtigen Funktionen/Eigenschaften in die gemeinsamme Vorfahrklasse integrieren und nur wenig genutzte, spezielle Methoden/Eigenschaften in die abgeleiteten Klassen. Natürlich sollte diese Aufgabenaufteilung auf die verschiedenen Klassen der Hierarchie auch einen Sinn/Nutzen beinhalten.

Ein Ausweg aus deiner Situation:

Leite TFahrzeug von TPersitent ab. Überschreibe die Methoden .Assign() oder .AssignTo()

<pre>

type
TFahrzeug = class(TPersistent)
procedure Assign(Source: TObject); override;
end;


procedure TFahrzeug.Assign(Source: TObject);
begin
if Source is TFahrzeug then
begin
FKennzeichen := TFahrzeug(Source).FKennzeichen;
... usw.
end else inherited Assign(Source);
end;

var
L: TLKW;
A: TAuto;
begin
L := TLKW.Create;
A := TAuto.Create;

A.Assign(L);
L.Assign(A);
end;

</pre>

ABER, obige Methode weist NICHT die Variablen L und A zueinander zu, sondern kopiert über die Methode .Assign die INHALTE der Objecte dieser Variablen.

Gruß Hage

[Frank Ambiel]

Hallo Adnan,

macht das ueberhaupt Sinn, Aepfel und Birnen einander zuzuweisen, nur weil beides unter den Begriff Obst faellt ?

Nun, in C++ koenntes Du Di jetzt einen eigenen Operator definieren, der das packt. Ansonsten bau Dir Doch eine Schnittstelle, d.h eine Methode in den beiden Klassen, die die Zuweisung uebernimmt

Also z. B.

Auto1 := LKW_To_Auto(LKW1);

Mf

[Hagen Reddmann]

Hi

Die Idee eine Zuweisung-Methode zu schreiben, ist genau der Ansatz der methoden Assign() und AssignTo().

Gruß Hage