Hallo zusammen,
ich bin von C++ auf Delphi umgestiegen und bin grad auf der Suche nach nem Abstrakt Fehler in einer DLL Datei ... dabei bin ich auf Folgendes Kosntrukt gestoßen:

zusammenfalten · markieren

Delphi-Quellcode:

TKlasse1 = class (TComponent)
private
...
public
constructor Create(AOwner: TComponent);

end;

TKlasse2 = class(TKlasse1)
private
...
public
constructor Create(AOwner: TComponent);

end;

TKlasse3 = class(TKlasse2)
private
...
public
constructor Create(AOwner: TComponent);

end;

TKlasse4 = class(TKlasse3)
private
...
public
constructor Create(AOwner: TComponent);

end;

impelentation

constructor TKlasse4.Create(AOwner: TComponent);
begin
inherited;
...
end;

constructor TKlasse3.Create(AOwner: TComponent);
begin
inherited;
...
end;

constructor TKlasse2.Create(AOwner: TComponent);
begin
inherited Create(AOwner);
end;

constructor TKlasse1.Create(AOwner: TComponent);
begin
....
end;

Kann mir jemand erklären ob es einen unterschied zwischen "inherited;" und "inherited Create(AComponent);" gibt? Und wenn ja welchen? Oder sind das einfach nur Altlasten von Delphi x.y. Achja ich weiß nicht ob das relevant ist ich nutze das RAD-Studio 2007.

Vielen Dank,

Tobi

inherited; ruft die identische Methode der Superklasse auf.
inherited Create(AComponent); ruft fest Create(AComponent); auf.
In diesem fall sollte es das selbe sein

Dazu hätte ich jetzt auch mal eine Frage.

Ziemlich oft habe ich Konstrukte wie folgende:

zusammenfalten · markieren

Delphi-Quellcode:

unit Unit1;

interface

type
  TBossClass = class(TObject)
  private
    Fv1: Integer;
  public
    constructor Create(v1: Integer);
  end;

  TChildClass = class(TBossClass)
  private
    Fv1, Fv2: Integer;
  public
    constructor Create(v1, v2: Integer);
  end;

  TSubChildClass = class(TChildClass)
  private
    Fv1, Fv2, Fv3: Integer;
  public
    constructor Create(v1, v2, v3: Integer);
  end;

implementation

constructor TBossClass.Create(v1: Integer);
begin
  Fv1 := v1;
end;

constructor TChildClass.Create(v1, v2: Integer);
begin
  inherited Create(v1);
// inherited; // <-- geht leider nicht ;(
  Fv2 := v2;
end;

constructor TSubChildClass.Create(v1, v2, v3: Integer);
begin
  inherited Create(v1, v2); // Wie ich so Fehler wie Create(v2, v1); hasse! Da sucht man Stunden nach! ._0
// inherited; // <-- geht immer noch nicht ;(
  Fv3 := v3;
end;

end.

Es gibt eine Oberklasse, von der ich immer mehr und immer weiter abgeleite, bis ich dann irgendwann am 'Endobjekt' bin.
Von diesen 'Endobjekten' muss ich dann oftmals ziemlich viele erstellen, da nervt es einfach immer wieder "inherited BluppMethode(MilliardenVonParametern, ....)" aufzurufen. Das ist nachher einfach nur noch ein erheblicher Zeitaufwand und wie ich gemerkt habe schleichen sich da schnell Flüchtigkeitsfehler ein. (Falsche Parameterreihenfolge)

Jetzt die eigentliche Frage:
Gibt es nicht irgendeine Möglichkeit, um die übergeordnete Methode mit deren normalen Parametern aufzurufen, ohne deren Parameter immer neu anzugeben?
(Beim überschreiben der Methoden kommen bei mir immer nur neue Parameter hinten dran)

Edit:
Ansonsten versuch ich mal ein IDE-Plugin zu schreiben.

Hallo,

der Compiler kann doch nicht wissen ob du inherited Create(v1, v2) meinst oder inherited Create(v2, v1) oder auch inherited Create(v1, 25) - das steht dir ja frei, mit oder ohne Hass.

Gruss Reinhard

Den Constructor nicht mit Parametern überfrachten.
Dafür gibt es Property.