Klasse im Array speichern -> Fehlermeldung

[himitsu]

Die Lösung wurde schon verraten, aber dennoch:

Zitat:

Delphi-Quellcode:

  MyViereck : TViereck;
  Punkt:Tpunkt;
  r:integer;
  z:integer;
  GeoArray :Tgeo_objectsarray;
  i :integer;
  Mydreieck:Tdreieck;

Warum sind diese Variablen global?
- GeoArray würde ganz gut in das PRIVATE der Form passen
- und der Rest sind eigentlich nur lokale Variablen, welche z.B. jeweils in die Button-Klick-Methoden gehören

Und warum greifen TDreieck und Co. direkt auf Form1 zu?

[DeddyH]

Zitat:

...ich wollte im Rahmen unseres Unterrichtes...

Noch Fragen?

[himitsu]

Zitat von DeddyH:

Noch Fragen?

Deswegen ja ... damit er und eventuell auch die Anderen und vorallem der Lehrer mal drüber nachdenken.
Und die Codeformatierung hab ich mal nicht erwähnt.

[MW97]

Wäre es hier nicht besser eine TObjectList zu nehmen? Dann könnte man sich das SetLength sparen und wenn er später mal ein Elemet entfernen möchte, brauch er nur Delete zu nehmen.

[hotkey]

Vielen Dank für die Antworten.

Ich weiß , dass das nicht sooo OOP ist.

Aber das was mir vorgeschlagen wird , mit Überschreiben abstract , virtual etc.

Das KENNE ich doch garnicht ?

Das haben wir im Unterricht noch nie behandelt , ich kann ja nix anwenden , was ich noch nicht hatte.

Klar , ich kanns raufklatschen und dann compilieren , kein Ding , aber ich will ja nachvollziehen und verstehen , was da gemacht wird.

Versteht ihr ?

[himitsu]

Hier ist eine "Basis"-Klasse, welche eine überschreibbare Methode enthält:

Delphi-Quellcode:

type
  TVorfahr = class
    procedure MachWas;
    procedure MachNochwas; virtual;
  end;

procedure TVorfahr.MachWas;
begin
  ShowMessage('ich bin MachWas von TVorfahr');
end;

procedure TVorfahr.MachNochwas;
begin
  ShowMessage('ich bin MachNochwas von TVorfahr');
end;

Wenn der Vorfahr noch keine Implementation dieser Methode benötigt, dann kann man sie abstact deklatieren.
(es befindet sich dann "noch" kein Code in dieser Methode)

Delphi-Quellcode:

type
  TVorfahr2 = class
    procedure MachWas;
    procedure MachNochwas; virtual; abstract;
  end;

procedure TVorfahr2.MachWas;
begin
  ShowMessage('ich bin MachWas von TVorfahr2');
end;

Ein Nachfahr kann nun diese Methode mit neuem Code überschreiben.

Delphi-Quellcode:

type
  TNachfahr = class(TVorfahr)
    procedure MachNochwas; override;
  end;

procedure TNachfahr.MachNochwas;
begin
  ShowMessage('ich bin MachNochwas von TNachfahr');
end;

Oder diese Methode wird ergänzt/erweitert, indem der Code des Vorfahren mit aufgerufen (inherited) wird.

Delphi-Quellcode:

type
  TAndererNachfahr = class(TVorfahr)
    procedure MachNochwas; override;
  end;

procedure TNachfahr.MachNochwas;
begin
  inherited;
  ShowMessage('ich bin MachNochwas von TNachfahr');
end;

Jenachdem welche Klasse nun erstellt wurde, kann man über die selbe Schnittstelle (hier die von TVorfahr) irgendeine Methode aufrufen, welche von einem Nachfahren überschrieben wurde.

Delphi-Quellcode:

var
  X: TVorfahr;

ShowMessage('jetzt kommt TVorfahr');
X := TVorfahr.Create;
try
  X.MachWas;
  X.MachNochwas;
finally
  X.Free;
end;

ShowMessage('jetzt kommt TNachfahr');
X := TNachfahr.Create;
try
  X.MachWas;
  X.MachNochwas;
finally
  X.Free;
end;

ShowMessage('jetzt kommt TAndererNachfahr');
X := TAndererNachfahr.Create;
try
  X.MachWas;
  X.MachNochwas;
finally
  X.Free;
end;

ShowMessage('jetzt ist Schluß');

Dem Code ist es also egal, ob und welcher Nachfahre verwentet wurde, da alle wichtigen Schnittstellen schon im Vorfahren existiert, welche man nun problemlos aufrufen kann.
Hier der Beweis:

Delphi-Quellcode:

var
  X: TVorfahr;
  i: Integer;

for i := 0 to 2 do begin
  case i of
    0: begin
      ShowMessage('jetzt kommt TVorfahr');
      X := TVorfahr.Create;
    end;
    1: begin
      ShowMessage('jetzt kommt TNachfahr');
      X := TNachfahr.Create;
    end;
    2: begin
      ShowMessage('jetzt kommt TAndererNachfahr');
      X := TAndererNachfahr.Create;
    end;
  end;
  try
    X.MachWas;
    X.MachNochwas;
  finally
    X.Free;
  end;
end;
ShowMessage('jetzt ist Schluß');

(statt der MessageBox, könnte man den Text auch in ein Memo schreiben)

[Sir Rufo]

Aber er hat das mit dem abstract und virtual ja noch nicht gehabt.

Allerdings frage ich mich, wie der Lehrer dann auf die Idee kommt, so eine Aufgabe zu stellen - vor dem Hintergrund OOP.

Entweder der TE hat da etwas verpasst oder der Lehrer verpennt