class - create

[Mathias]

Wieso kommt diese Warnung:

...\standrohrunit.pas(23,17) Warning: An inherited method is hidden by "constructor TStandRohrSchnitt.Create;"

Create ist pubilic, wieso schreibt er was von hidden.

Code: Alles auswählen

  TStandRohrSchnitt = class(TUrAnzeiger)
  public
    constructor Create;
    procedure WriteVertex;
  end;
 

[Christian]

weil es in der Vaterklasse schon nen Constructor gibt der genauso auschaut, und du den eigentlich überschreiben solltest denn der könnte ja vllt was sinnvolles tun sonst wär er nicht da. Da der Compiler sich aber nicht sicher sein kann das alles was da ist auch sinn macht, erzeugt er nur ne warnung.

[Mathias]

Ich hätte den Constructor auch posten sollen, da wird der Vater-Constructor aufgerufen.

Code: Alles auswählen

constructor TStandRohrSchnitt.Create;
begin
  inherited Create;
  Color := vec4(1.0, 0.0, 0.0, 0.0);
end;  

[theo]

Ein "override" bei der Deklaration wäre sinnvoll.

[Mathias]

Wieso override ?

Es ist ja ein ganz gewöhnlicher Nachkomme. Überladen tue ich auch nichts.

Hier schreiben sie, das es bei Destroy zwingen ein overlaod bracht, bei Create nur wen man es überladet.
Link

[m.fuchs]

Du bringst hier gerade Überschreiben (override) und Überladen (overload) durcheinander.
Der Konstruktor von TUrAnzeiger ist wohl mit virtual gekennzeichnet. Deswegen wäre ein override beim Konstruktor der abgeleiteten Klasse ganz nett.

[Mathias]

Wen ich dich richtig verstehe, braucht der Nachkomme einer virtual deklarierten Methode ein override.

So wie es in diesem Beispiel ist. Link

[m.fuchs]

Wen ich dich richtig verstehe, braucht der Nachkomme einer virtual deklarierten Methode ein override.

Nein, braucht er nicht unbedingt, wie du gesehen hast geht es auch ohne. Die Frage ist nur ob der Nachkomme sich dann so verhält wie du möchtest.
Ein Beispiel zur Verdeutlichung:

Code: Alles auswählen

program PolymorphieTest;
{$mode objfpc}{$H+}
 
uses
  Classes, SysUtils;
 
type
  TBaseClass = class(TObject)
    procedure Test; virtual;
  end;
 
  TOverrideClass = class(TBaseClass)
    procedure Test; override;
  end;
 
  TNonOverrideClass = class(TBaseClass)
    procedure Test;
  end;
 
procedure TNonOverrideClass.Test;
begin
  WriteLn('TNonOverrideClass.Test');
end;
 
procedure TOverrideClass.Test;
begin
  WriteLn('TOverrideClass.Test');
end;
 
procedure TBaseClass.Test;
begin
  WriteLn('TBaseClass.Test');
end;
 
var
  MyObject: TBaseClass;
 
begin
  MyObject := TBaseClass.Create;
  MyObject.Test;
  FreeAndNil(MyObject);
  MyObject := TOverrideClass.Create;
  MyObject.Test;
  FreeAndNil(MyObject);
  MyObject := TNonOverrideClass.Create;
  MyObject.Test;
  FreeAndNil(MyObject);
  ReadLn;
end.

Probier es mal aus.

[Mathias]

Interessantes Beispiel.

So sieht man das override macht viel Sinn, ohne diese Deklaration nützt virtual auch nichts.

Das dies geht hätte ich nicht gedacht: MyObject := TOverrideClass.Create; Ich meint das Create müsste immer mit der in var deklarieten Classe übereinstimmen: MyObject := TBaseClass.Create;

Der Befehl ist mir auch neu: FreeAndNil(MyObject); Ich hatte jetzt immer MyObject.Free geschrieben.

Ich hatte unterdessen auch ein Beispiel geschrieben und probiert.
Je nach Ausgabe mit override deklariere oder nicht verhält sich mein Programm anders.

Code: Alles auswählen

unit Unit1;
 
{$mode objfpc}{$H+}
 
interface
 
uses
  Forms, StdCtrls;
 
type
 
  { TForm1 }
 
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { private declarations }
  public
    { public declarations }
  end;
 
  { TVater }
 
  TVater = class(TObject)
    constructor Create; virtual;
    procedure Ausgabe; virtual;
  end;
 
  { TKind }
 
  TKind = class(TVater)
    constructor Create; override;
    procedure Ausgabe; override;
  end;
 
 
var
  Form1: TForm1;
 
implementation
 
{$R *.lfm}
 
{ TForm1 }
 
procedure TForm1.Button1Click(Sender: TObject);
var
  Kind: TKind;
begin
  Kind := TKind.Create;
  Kind.Free;
  Writeln('------------');
end;
 
{ TKind }
 
constructor TKind.Create;
begin
  inherited;
  Writeln('TKind Create');
end;
 
procedure TKind.Ausgabe;
begin
  Writeln('TKind Ausgabe');
  inherited;
end;
 
{ TVater }
 
constructor TVater.Create;
begin
  Writeln('TVater Create');
  Ausgabe;
end;
 
procedure TVater.Ausgabe;
begin
  Writeln('TVater Ausgabe');
end;
 
end.

[m.fuchs]

macht viel Sinn

Aua .

Das dies geht hätte ich nicht gedacht: MyObject := TOverrideClass.Create; Ich meint das Create müsste immer mit der in var deklarieten Classe übereinstimmen: MyObject := TBaseClass.Create;

Nö, es kann auch ein Abkömmling sein. Allerdings kannst du nur auf die Methoden der Basisklasse zugreifen. Und indirekt eben über die virtuellen Methoden auf die eigentliche Klasse.

Der Befehl ist mir auch neu: FreeAndNil(MyObject); Ich hatte jetzt immer MyObject.Free geschrieben.

Ich habe mir fast vollständig abgewöhnt .Free einzusetzen. Somit ist dann auch immer sichergestellt, dass die Referenzvariable danach auf nil zeigt. Bei der Nutzung von Assigned ist das immer hilfreich.

[Mathias]

Wen ich dich richtig verstehe, braucht der Nachkomme einer virtual deklarierten Methode ein override.

Nein, braucht er nicht unbedingt, wie du gesehen hast geht es auch ohne. Die Frage ist nur ob der Nachkomme sich dann so verhält wie du möchtest.
Ein Beispiel zur Verdeutlichung:

Jetzt weis ich wieso ich nirgends ein override geschrieben habe, früher habe ich nur mit Objecten gearbeitet, und dort braucht es ein virtual bei den Nachkommen.

[Mathias]

Ist dies der normale Weg, wen man mehrfach-vererbt, bezieht sich auf das override.

Code: Alles auswählen

  { TGrossVater }
 
  TGrossVater = class(TObject)
    constructor Create; virtual;
    procedure Ausgabe; virtual;
  end;
 
  { TVater }
 
  TVater = class(TGrossVater)
    constructor Create; override;
    procedure Ausgabe; override;
  end;
 
  { TKind }
 
  TKind = class(TVater)
    constructor Create; override;
    procedure Ausgabe; override;
  end;         

[m.fuchs]

Jepp, genauso ist es richtig.

[Mathias]

Wen ich hier gucke, sieht es aus, wie wen ich bei create virtual und override ganz weglassen kann.
Das ich überhaupt auf die Idee ist kam, liegt wahrscheinlich, weil ich overload und override verwechselt hatte.
Das override braucht es nur bei Destroy.

Dazu habe ich noch eine Frage:
Man gibt eine Class mit MyClass.Free frei, wo wird dies freigegeben ?
Der Methode Free und Destroy mach ja nichts.

Ein Ausschnitt aus der Original-Quelle von FreePascal (objpas.inc).

Code: Alles auswählen

      destructor TObject.Destroy;
        begin
        end;
 
      procedure TObject.Free;
 
        begin
           // the call via self avoids a warning
           if self<>nil then
             self.destroy;
        end;                   

[m.fuchs]

Wen ich hier gucke, sieht es aus, wie wen ich bei create virtual und override ganz weglassen kann.

Nun, das kommt ganz darauf an, was du brauchst. Mein Beispiel von oben funktioniert nur mit virtual und override. Aber es ist ja nicht gesagt, dass diese Funktionalität gewünscht ist.

Das override braucht es nur bei Destroy.

Da aber dann definitiv.

Dazu habe ich noch eine Frage:
Man gibt eine Class mit MyClass.Free frei, wo wird dies freigegeben ?
Der Methode Free und Destroy mach ja nichts.

Das ist Magie. Die Methode FreeInstance ist für das Aufräumen verantwortlich.