Constructor in der Vererbung

[Captnemo]

Hi,

ich habe mir eine Basisklasse erstellt:

Delphi-Quellcode:

type
  TBefehl = class(TObject)
  private
    fGUID: Ansistring;
    constructor Create;
  published
    ...
  public
    ...
  end;

Published und Public hab ich hier mal weggelassen.

Im Constructor Create wird eine GUID erzeugt, die in fGUID gespeichert wird.

Jetzt erstelle ich mir noch eine Klasse aus meiner Basisklasse:

Delphi-Quellcode:

type
  TECHO = class(TBefehl)
  private
    ...
  published
    ...
  public
    ...
  end;

Auch hier hab ich mal die Variablen, Properties, Proceduren und co. weggelassen.

Grundsätzlich hätt ich jetzt gedacht, meine Klasse TECHO (hat keinen eigenen Constructor) erbt von der TBefehl den Constructor Create, so wie die Klasse TBefehl eben diesen von TObject erbt.
Aber, mein Constructor wird nie ausgeführt.

Hab ich das falsch verstanden und mache einen Denkfehler?

[FaTaLGuiLLoTiNe]

Wenn du von ausserhalb deiner Klassenhierarchie TBefehl.Create bzw. TECHO.Create verwendest, dann wird nicht der private Konstruktor der Klasse TBefehl aufgerufen (der ist ja nach aussen auch gar nicht sichtbar), sondern der öffentliche Konstruktor von TObject. Und der macht so ziemlich gar nichts.

Du kannst ja mal probieren, TBefehl.Create zu verwenden (von ausserhalb der Klasse TBefehl). Du müsstest eine Fehlermeldung bekommen.


// Edit: Private Konstruktoren machen eigentlich nur Sinn, um von innerhalb derselben Klasse (z.B. in einer Factorymethode) verwendet zu werden. An deiner Stelle würde ich den Konstruktor von TBefehl einfach als public deklarieren und je nachdem auch noch virtuell machen.

[DeddyH]

Ist ein privater Konstruktor nicht an sich schon ziemlich sinnentleert?

[Der schöne Günther]

Leider wäre er nur vollkommen sinnentleert wenn Delphi nicht so eine komische Definition von Sichtbarkeiten hätte. "Private" heißt ja nur "Diese Klasse und gleich noch alles in dieser Unit auch". "Strict private" wäre vollkommen sinnentleert.

Noch am Rande: Warum ist fGuid ein String und keine TGUID?

[Captnemo]

Zitat von Der schöne Günther:

Leider wäre er nur vollkommen sinnentleert wenn Delphi nicht so eine komische Definition von Sichtbarkeiten hätte. "Private" heißt ja nur "Diese Klasse und gleich noch alles in dieser Unit auch". "Strict private" wäre vollkommen sinnentleert.

So hatte ich das auch gelesen. Also innerhalb der gleichen Unit sollte das ja gehen.
Da TEcho sich in der gleichen Unit befindet, dachte ich, da ich diese aus TBefehl ableite, dass sie auch deren Create verwendet. Die Klasse TBefehl wird in meinem Prog nie direkt erzeugt, sondern dient nur als Basis für anderen Objecte.

Aber: Constructor in Public....schon geht's. Gut, dann hab ich das vielleicht nicht ganz richtig verstanden.
Wenn ich mein Object TECHO in der gleichen Unit erzeugt hätte, hätte es vielleicht auch so funktioniert.

Zitat von Der schöne Günther:

Noch am Rande: Warum ist fGuid ein String und keine TGUID?

Weil ich im Grunde innerhalb meiner Objecte irgendeinen eindeutigen Namen brauchte, den aber als Ansistring. Hätt natürlich auch als TGUID machen können. Aber dann hätt ich sooft umwandeln müssen, also gleich als String;

[Der schöne Günther]

Wenn du beide in die gleiche Unit gepackt hast (Igitt!) dann sollte es eigentlich gehen! Kannst du ein reproduzierbares Minimalbeispiel einstellen?

Delphi-Quellcode:

program Project2;

{$APPTYPE CONSOLE}

{$R *.res}

type

   TBaseClass = class
      (*strict*)private constructor Create();
   end;

   TSubClass = class(TBaseClass)
      // Nichts
    end;

{ TBaseClass }

constructor TBaseClass.Create();
begin
   WriteLn('Hallo');
end;

begin
   TSubClass.Create();
   ReadLn;
end.

[himitsu]

Dein Constructor wird ausgeführt, wenn er an der Stelle des Aufrufs sichtbar ist. (also nur innerhalb der Unit)

PS: in der RTTI gibt es eine Klasse, da wollte Emba unbedingt allen "fremden" den Aufruf des Constructors, bzw. das Erstellen der Klasse verbieten.
- Es gibt einen privaten constructor, welcher nur innerhalb der eigenen Unit vom eigenem Code aufgerufen werden kann.
- Und es gibt einen public Constructor, in dem nichts Anderes gemacht wird, außer eine Exceptions "nee, DU nicht!" zu werfen.

[Captnemo]

Na klar

Unit BABClasses:

Delphi-Quellcode:

unit BABclasses;

interface

uses System.Contnrs, System.Classes, System.SysUtils;

type
  TBefehl = class(TObject)
  private
    fGuid: AnsiString;
  published
    property Guid: AnsiString read fGuid write fGuid;
  public
    constructor Create;
  end;

type
  TECHO = class(TBefehl)
  private
    fText: AnsiString;
  published
    property Text: AnsiString read fText write fText;
  end;

implementation

constructor TBefehl.Create;
var
  g: TGUID;
begin
  inherited Create;
  CreateGUID(g);
  self.fGuid:=GUIDToString(g);
end;

end.

Unit Main:

Delphi-Quellcode:

unit main;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Vcl.ExtCtrls, Vcl.ComCtrls,
  Vcl.Buttons, BABclasses, Vcl.Menus, System.Contnrs;

type
  Tfrm_batchdefinition = class(TForm)
    lst_test: TListBox;
    btn_Add: TSpeedButton;
    procedure btn_AddClick(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    BefehlsListe: TObjectList;
    { Public-Deklarationen }
  end;

var
  frm_main: Tfrm_main;

implementation

{$R *.dfm}

procedure Tfrm_main.FormCreate(Sender: TObject);
begin
  Befehlsliste:=TObjectList.Create;
end;

procedure Tfrm_main.FormDestroy(Sender: TObject);
begin
  Befehlsliste.free;
end;

procedure Tfrm_main.btn_AddClick(Sender: TObject);
var
  echo: TECHO;
begin
  echo:=TECHO.Create;
  lst_temp.items.add(echo.guid);
end;

Ich habs aber mal zusammengekürzt, kann nicht alles hier posten. So aber in etwa. Hier habe ich das Create in Public, und so geht's auch.

[himitsu]

Wie wäre es, wenn die TObjectList auch noch auf OwnsObject umgestellt wird?

Oder man verwendet stattdessen eine generische TObjektList<TBefehl>, oder eine TCollection, bzw. eine TQueue<TBefehl> usw., welche sich auch um die Freigabe der Objekte kümmern.

Statt die Objekte manuell zu erstellen, kann man der Liste auch Funktionen verpassen, welche diese Instanzen intern erstellen und zu sich hinzufügen.

[Stevie]

Zitat von Captnemo:

Aber: Constructor in Public....schon geht's. Gut, dann hab ich das vielleicht nicht ganz richtig verstanden.
Wenn ich mein Object TECHO in der gleichen Unit erzeugt hätte, hätte es vielleicht auch so funktioniert.

In der Unit Main ist der Konstruktor von TBefehl nicht sichtbar, wenn er private ist. Daher bleibt dort nur die Möglichkeit, den Konstruktor von TObject aufzurufen, der ja immer verfügbar ist. Auch wenn, TEcho in derselben Unit gewesen wäre, hätte das nichts geändert. Denn auch dann wäre der Konstruktor nicht sichtbar gewesen, da er ja Teil von TBefehl ist.

Private sollte man grundsätzlich nur Member machen, die nur innerhalb dieser Klasse benutzt werden.