"Abstrakter Fehler" schon zur Compile-Zeit unterbinden

[DelphiBandit]

Hallo zusammen,

wenn ich eine Grundklasse mit abstrakten virtuellen Methoden ableite und diese dann in der erbenden Klasse nicht deklariere, bekomme ich den Fehler erst als Laufzeitfehler "Abstrakter Fehler" mitgeteilt.

Gibt es keine Möglichkeit den Compiler (hier RS 2007) zu überreden mich auf solche Unstimmigkeiten hinzuweisen? Bekomme eine Warnung vom Compiler, dass eine Instanz mit abstrakten Methoden angelegt wird. Aber keinen Compiler-Fehler. Oder ein Keyword was eine Ableitung zwingend erforderlich macht?

Andere Möglichkeit wäre der Einsatz eines Interface, dieses macht die Implementierung in den nutzenden Objekten erforderlich, aber das ist mir ein wenig viel Overhead mit der internen Zählung etc. Eigentlich nicht notwendig für meine einfachen Objekte.

Bin für jeden Tipp dankbar

Carsten

----
Beispiel (nein, aase normalerweise nicht mit globalen Var's und initialization/finalization herum - wollte mir nur weitere Events wie OnCreate sparen) -> siehe //

Delphi-Quellcode:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TGrundklasse = class(TObject)
    private
       function FunktionEins: Boolean; virtual; abstract;
  end;

  TAbleitung = class(TGrundklasse)
    private
       function FunktionEins: Boolean; override; // Diese Zeile kommentieren -> "Abstrakter Fehler"
  end;

  TForm1 = class(TForm)
    btn1: TButton;
    procedure btn1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;
  tobj: TAbleitung;

implementation

{$R *.dfm}

procedure TForm1.btn1Click(Sender: TObject);
begin
   tobj.FunktionEins;
end;

{ TAbleitung }
// Hier auch kommentieren
function TAbleitung.FunktionEins: Boolean;
begin
  MessageDlg('Funktion ist deklariert und funktioniert', mtInformation, [mbOK], 0);
  Result := True;
end;

initialization
  tobj := TAbleitung.Create;

finalization
  tobj.Free;

end.

[himitsu]

[edit]
*was falsch verstanden*

[mkinzler]

Deklariere die Klasse als abstrakt und nicht die Methode
(Bin mir aber nicht sicher, mit welcher Version von Delphi diese Möglichkeit kam)

[sirius]

Zitat:

Zitat von himitsu

Einfache und sogar die offizielle Lösung: definiere die abstrakten Methoden ... notfalls einfach leer (ohne Code) lassen.

Mit einer abstrakten Methode möchte man aber gerade den Entwickler dazu zwingen, diese Methode zu implementieren. Und eine Warnung gibt es ja. Wer Warnungen ignoriert ist selber Schuld.

@mkinzler: TGrundklasse wäre abstrakt, aber TAbleitung ja nicht mehr.


Ich frag mich: Was hat der Compiler eigentlich für Chancen abstrakte Fehler zu erkennen. Teilweise könnt er hinbekommen, wie hier, wenn die Klasse direkt instanziert wird. aber anscheinend geht Delphi den Weg, den Nutzer einfach nur zu warnen, vielleicht braucht er ja die abstrakten Methoden nicht.
Aber welche Chance hat Delphi, wenn du eine abstrakte Klasse aus einer Metaklasse heraus erzeugst? Keine! Da gibt es auch keine Compilerwarnung.
Ich würde sage, hier reicht es, wenn der Entwickler einmal mitdenkt.

[DelphiBandit]

Zitat:

Zitat von himitsu

Einfache und sogar die offizielle Lösung: definiere die abstrakten Methoden ... notfalls einfach leer (ohne Code) lassen.

OK, verstehe das mal als: Einfach aufpassen und alles implementieren! Und ab und zu einen Blick in die Compiler-Warnings werfen. Schade, hatte die Hoffnung, dass es eine Compiler-Direktive gibt, die einem dieses Konstrukt verbietet.

Danke erstmal

[himitsu]

Neee, hatte es etwas falsch verstanden.

Komisch, denn eigentlich sollte der Compiler hier nicht meckern,

es sei denn du versuchst irgendwo eine Instanz von TGrundklasse zu erzeugen, auf was die Fehlermeldung hinweisen würde. :gruebel:


In welcher Zeile meckert denn Delphi und wie sieht diese Zeile aus?

[uligerhardt]

Zitat:

Zitat von HondaGL1

Zitat:

Zitat von himitsu

Einfache und sogar die offizielle Lösung: definiere die abstrakten Methoden ... notfalls einfach leer (ohne Code) lassen.

OK, verstehe das mal als: Einfach aufpassen und alles implementieren! Und ab und zu einen Blick in die Compiler-Warnings werfen. Schade, hatte die Hoffnung, dass es eine Compiler-Direktive gibt, die einem dieses Konstrukt verbietet.

Mit neueren Delphiversionen (ab D2009?) könnte das funktionieren:

Delphi-Quellcode:

{$WARN CONSTRUCTING_ABSTRACT ERROR}

Kann's leider nicht ausprobieren, da wir bei D2007 hängengeblieben sind.

[DelphiBandit]

Zitat:

Zitat von uligehardt

Mit neueren Delphiversionen (ab D2009?) könnte das funktionieren:

Delphi-Quellcode:

{$WARN CONSTRUCTING_ABSTRACT ERROR}

Kann's leider nicht ausprobieren, da wir bei D2007 hängengeblieben sind.

Danke für den Tipp, aber wir arbeiten auch nur mit D2007. Werde ich aber @home mal probieren, dort nutze ich die neuere Version.

Zitat:

Zitat von himitusu

In welcher Zeile meckert denn Delphi und wie sieht diese Zeile aus?

Gemeckert wird zur Laufzeit in Zeile 40 (logisch), das Warning bezieht sich bei auskommentierter Ableitung auf das Create im Initialization-Abschnitt.

Wenn das nicht geht ist es auch kein Drama! Hatte nur die Hoffnung ich kann uns mit einer Compiler-Einstellung das Leben ein wenig erleichtern. Ansonsten hat sirius natürlich Recht.

[Neutral General]

Hallo,

Der Thread ist zwar schon etwas älter aber ich habe quasi das gleiche "Problem".
Ich hätte gerne, dass der Compiler einen Fehler meldet, wenn ich in einer abgeleiteten Klasse eine abstrakte Methode nicht überschrieben habe.
Also quasi wie wenn man eine Methode eines benutzten Interfaces nicht implementiert.

Gibt es da mittlerweile (in den neuen Delphi Versionen) eine Möglichkeit?
Dieses

Delphi-Quellcode:

{$WARN CONSTRUCTING_ABSTRACT ERROR}

Hat bei mir nicht funktioniert. Es sei denn ich habe irgendwas falsch gemacht...

[himitsu]

In XE2 funktiniert Folgendes ganz gut.

Delphi-Quellcode:

{$WARN CONSTRUCTING_ABSTRACT ERROR}   // Error

{$WARN CONSTRUCTING_ABSTRACT ON}      // Warning (Standard)

{$WARN CONSTRUCTING_ABSTRACT OFF}     // Nix

Also dort, wo man versucht eine Klasseninstanz zu erstellen.
Aber natürlich nur dort, wo man das Create direkt über den Typ aufruft.

Delphi-Quellcode:

TMyAbstractClass.Create; // Fehler

C := TMyAbstractClass;
C.Create;  // nix

Ob und bis zu welchem Delphi es runter geht ... kann ich erst später sagen.

[edit]
Ab D2009 gibt es keine Probleme. (ERROR funktionierte überall)
Davor (in 2007) ist nur ON und OFF verfügbar.

[Neutral General]

Hallo,

Das Problem ist, dass ich abstrakte Klassenmethoden habe und die Klasse selbst voraussichtlich niemals erzeugt werden wird. Deshalb wäre es ganz praktisch wenn ich schon vorher eine Meldung bekäme.

[himitsu]

Es ist aber sicher, daß diese Klasse von irgendwem erzeugt wird?

Du könntest im Class-Contructor deiner Klasse einen Create-Aufruf einbauen, versteckt in einem IF, welches nie aufgerufen wird (was der Compiler aber nicht merken darf).
Für ältere Delphis in der Initialization.

[Neutral General]

Prinzipiell ginge das sicher.

Es geht mir darum dass ich eine Basisklasse mit mehreren abstrakten Methoden habe und davon abgeleitet gefühlte 10000 Klassen. Jetzt habe ich Angst, dass ich im Programmier-Eifer vergesse die ein oder andere Methode in den Subklassen zu überschreiben. Wenn ich jetzt für jede Subklasse einen Class-constructor erstellen soll/will/muss.. dann verlager ich das Problem ja nur an eine andere Stelle :/

[himitsu]

Hmmm.

Nja, das Problem ist ja, daß der Compiler nicht weiß, daß diese Klassen doch irgendwo anderes erzeugt werden sollen.
Und bei Klassen die nicht erzeugt werden, wird auch nicht gemeckert, sonst würde ja jedesmal sowas wie TStream knallrot aufleuchten.

Du kannst dir auch "einfach" ein Testprojekt anlegen, dort stehen dann hintereinander ganz viele Create-Aufrufe.

[Neutral General]

Mh. Ich glaube ich überlege mir eine alternative, evtl. bessere Lösung für mein Problem ohne diese ganzen Klassenmethoden und 1000 Ableitungen.
Wird am Ende dann wahrscheinlich sogar die sauberere Lösung sein...

Danke trotzdem für die Bemühungen ;)