Hallo allerseits, ich bin heute nach vielen Jahren Softwareentwicklung mal wieder aus allen Wolken gefallen. Ich habe gelernt: (in Delphi?) kann auf alle Funktionen/Proceduren einer Klasse (variable) zugegriffen werden, egal ob instanziiert oder nicht.

ich habe etwas recherchiert und hier ist es auch ganz gut erklärt, wobei die erklärung am ende heißt: es ist in delphi so, da constructor und destructor.... : http://stackoverflow.com/questions/8...freeing-things

jedenfalls heißt dies, ich kann jede procedure einer klasse starten, egal ob die klasse instanziiert wurde, oder nicht. erstelle ich zB eine

zusammenfalten · markieren

Delphi-Quellcode:

procedure myform.ButtonClick;
...
myClass.doSomething(TMyInputClass.Create(Edit1.Text));


procedure TmyClasss.doSomething(InputKlasse : TMyInputClass);
begin
 If InpuKlasse.Stauts1 then
    Result:='X'
   else
    Result:=Self.Y
end;

kann ich mir nicht sicher sein, das object auf das ich zugreife überhaupt instanziiert ist, weil funktionen funktionen in bestimmten zuständen trotzdem durchlaufen werden. somit wird mir jetzt auch klar wieso man soviele "schwachsinnige" fehlermeldungen erhält, welche an nicht zuordenbaren stellen ausgelöst werden. je nachdem ob "zufällig" auf eine Variable des Objects zugegriffen wird, erhalte ich eine Fehlermeldung und ansonsten nicht.

ist dies in anderen Sprachen auch so? für mich war bisher immer ein paradigma: ich kann nur auf elemente einer instanziierten Klasse zugreifen. (ausnahmen sind zB "class procedure", "class var").

insbesondere beim schliessen einer Anwendung ist das ja interessant: je nachdem welcher finalization abschnitt zuerst durchlaufen wird, bzw. wie die erstellungsreihenfolge und somit freigabereihenfolge ist, habe ich unterschiedliche zustände und erhalte fehlermeldungen von "klassen", die vor "ewigkeiten" freigegeben wurden nur, weil zufällig eine reihe von proceduren/properties aufeinandergetroffen ist, welche nicht nachvollziehbar ist und die fehlermeldung von ganz woanders herführt, wo ein NIL-zeiger ist, der sozusagen trotzdem ausgeführt wird?!

somit ist ja auch sogleich ein stacktrace alla eurekalog/madexcept teilweise unbrauchbar. habe ich in meinem stacktrace 10 unterschiedliche klassen, ist nicht nachvollziehbar welche davon nun tatsächlich nil war, da ja "blind" alles ausgelöst wird bis eben "zufällig" auf eine lokale klassenvariable zugegriffen wird.

Ich wage es anzuzweifeln, das man in Delphi auf Nicht statische ( class procedure) Funktionen zugreifen kann ohne das Objekt vorher zu instanziieren. Das mag vieleicht in einigen Faellen zufaellige funktionieren, ich bekomme bei sowas immer AV.
Zudem, nicht ganz von der Hand zu weisen, warum gibts dann einen Constructor/Destructor, wenn ich die Klasse nicht erzeugen muss?

... Oder steh ich grad auf'm Schlauch?

Cheers Mathias

So wie ich das sehe, kannst Du eine Methode, die aufgrund ihrer fehlenden Referenzen zu privaten Feldern (auch indirekt) auch statisch deklariert sein könnte, auch dann aufrufen, wenn das Objekt nicht instantiiert ist, da keinerlei undefinierte Referenzen verwendet werden.

Zitat von DSCHUCH:

myClass.doSomething(TMyInputClass.Create(Edit1.Text));

Logo, du hast ja innerhalb von myClass.doSomething die Instanz TMyInputClass.Create.

Ja ja, aber myClass ist doch nicht instantiiert, und dessen Methode wird aufgerufen....

Ja sicher, in dem Moment, wo er TMyInputClass aber erzeugt, ist die doch verfügbar?

genau und damit greift er, wie Furtbichler es schon geschrieben hat, auf Elemente zu, die initialisiert sind. Sobald er auf ein Feld der eigenen KLasse zugreift geht es schief.

Beispiel:

zusammenfalten · markieren

Delphi-Quellcode:

type
  TMyStringList = class(TStringList)
    procedure DoSomeThing(List: TMyStringList);
  end;

  TForm2 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  end;


procedure TMyStringList.DoSomeThing(List: TMyStringList);
begin
  List.Add('Test');
  ShowMessage(IntToStr(List.Count));
  // ShowMessage(IntToStr(Self.Count)); *** AV
end;

procedure TForm2.Button1Click(Sender: TObject);
var
  List: TMyStringList;
begin
  List.DoSomeThing(TMyStringList.Create);
  List.Free;
end;

end.

nein, der Parameter 'InputKlasse' ist instantiiert, aber nicht die Instanz 'MyClass', dessen Methode aufgerufen wird.

sehr gut, ich bin nicht der einzige der da schaut wie ein pferd ins uhrwerk.

hier mal ein einfaches bsp.

zusammenfalten · markieren

Delphi-Quellcode:

  Tc = class(TComponent)
    private
     F : TComponent;
     class var I : Integer;
     function GetPrivateF : String;
    public
     procedure t;
    published
     property getF : String read GetPrivateF;
  end;

function Tc.GetPrivateF: String;
begin
 ShowMessage('Here i am');
 Application.ProcessMessages; //wir aufgerufen von einem nicht existierenden Objekt!!!
 Application.DoSomething(Self); //ruft eine weitere Methode aus nicht exisitierendem Objekt auf, mit einem NIL zeiger auf Self.
 Exit('Ok')
end;

procedure Tc.t;
begin
 ShowMessage('test');
 if Assigned(Self) then
    ShowMessage('Self is Assigned')
   else
    ShowMessage('Self is not Assigned');//analog Free (wo ich geacht hätte es wäre eine art class procedure und daher mit nil aufrufbar)
end;


procedure TForm6.Button1Click(Sender: TObject);
var C : TC;
begin
 C:=nil;
 //ShowMessage(C.Name);
 ShowMessage(C.getF);
end;

procedure TForm6.Button2Click(Sender: TObject);
var C : TC;
begin
 C:=nil;
 //ShowMessage(C.Name);
 C.t;
end;