Wozu CREATE zur Instantiirung eigener Objektklassen?

[EccoBravo]

Hallo, mal wieder eine Ober-Dummie-Frage

Ich erzeuge mir eine eigene Klasse im Type-Abschnitt meines Programmes und erzeuge mir im var-Abschnitt eine konkrete Instanzen (meinKreis1, meinKreis2) davon. Dann habe ich mit diesen Instanzen einfach "drauf los-" programmiert. Das ging auch.

so sieht es immer bei mir aus:

Delphi-Quellcode:

// ein UnitCode zur Klassenerzeugung

Unit Kreis;

interface

type TCycle = Class(TObject);
  private
    F_Radius : single;
    function getPeriph : single;
    procedure setPeriph(periph : single);
  public
    property radius : single read F_Radius write F_Radius;
    property umfang : single read getPeriph write setPeriph;
  end;

implementation

function TCycle.getPeriph;
begin
  result := 2*Pi*F_Radius;
end;

procedure TCycle.setPeriph(periph:single);
begin
  F_Radius := periph / 2 / Pi;
end;

//..............................................
//...
// Implementationsteil des Anwendercodes:
//...

uses kreis;

var
  meinKreis1, meinKreis2 : TCycle;

procedure TForm1.FormCreate(Sender:TObject);
begin
  // bei mir wird hier nichts mit meinKreis1 und meinKreis2 gemacht
  // Im Implement.-Teil werden diese Instanzen einfach nur benutzt.  

end;
...

Aber wozu ist denn die Create-Methode nötig, die vor meinem Drauf-Los-Programmieren mit den konkreten Instanzen meinKreis1, meinKreis2 aufgerrufen wird (Laut Literatur):

Delphi-Quellcode:

// ein UnitCode zur Klassenerzeugung

Unit Kreis;

interface

type TCycle = Class(TObject);
  private
    F_Radius : single;
    function getPeriph : single;
    procedure setPeriph(periph : single);
  public
    property radius : single read F_Radius write F_Radius;
    property umfang : single read getPeriph write setPeriph;
  end;

implementation

function TCycle.getPeriph;
begin
  result := 2*Pi*F_Radius;
end;

procedure TCycle.setPeriph(periph:single);
begin
  F_Radius := periph / 2 / Pi;
end;

//...............................................
//...
// Implementationsteil des Anwendercodes:
//...

uses kreis;

var
  meinKreis1, meinKreis2 : TCycle;

procedure TForm1.FormCreate(Sender:TObject);
begin
  meinKreis1 := TCycle.Create    // und dieses ist meine Frage
  meinKreis2 := TCycle.Create    // wozu?, was ist der Unterschied zu meinem obigen..?
end;
...

Und noch eine Frage:
Wo landet der Sender:TObject ?
immer nur stillschweigend verwendet aber nie gewußt warum?


Danke, Danke E. B.

[alzaimar]

Deine Instanzen verweisen irgendwo auf den Speicher. Du schreibst dort lustig etwas rein. Andere Programmteile könnten dort auch etwas reinschreiben, wer weiss?

Da Du keine Unterprogramme verwendest oder sonst etwas komplexes mit deiner SW anstellst, klappt das vielleicht auch.

Mit 'Create' reservierst Du Speicher. Dieser Speicher ist exklusiv für diese Instanz reserviert (bist Du ihn mit 'Destroy') wieder freigibst.

[3_of_8]

...wobei man besser Free statt Destroy aufrufen sollte.

Nebenbei ist noch zu sagen, dass ein Zugriff auf nicht-instantiierte Objekte zumindest bei mir immer AVs verursacht, liegt vllt an der aktivierten Bereichsprüfung.

[mkinzler]

Nicht instantiierte Objekte sind ja nur referenzen (Zeiger 32-Bit) auf was willst du zugreifen, wenn kein Objekt besteht?

[Luckie]

Also, da fehlen wirklich die (theoretischen) Grundlagen. Eine Ausbildung macht doch irgendwie Sinn. ;)

Grundsätzlich stellen sich hier drei Fragen:

1. Was ist eine Klasse?
2. Welche Funktion hat sie?
3. Was ist ein Objekt?

1. Eine Klasse beschreibt eine Menge (von irgendwas) welche gleichartige Attribute und Methoden besitzen.

2. Eine Klasse ist ein Bauplan, der beschreibt, wie etwas auszusehen hat. Oder mann kann auch sagen, ein Vordruck für ein Formular.

3. Ein Objekt ist eine Instanz einer Klasse. Oder anders gesagt ein Abbild der Klasse im Speicher mit dem man arbeiten kann.


Geht man von dem Vergleich mit einem Formular aus, dann ist es ja so, dass man auch nicht in den Vordruck des Formulars direkt reinschreibt, sondern man macht sich eine Kopie und füllt dann die Kopie aus. Genauso ist es auch mit einer Klasse und einem Objekt. Um eine Klasse benutzen zu können, muss man eine Instanz (Kopie) von ihr im Speicher anlegen. Diese Kopie der Klasse im Speicher nennt man Objekt.

Die Delphi Syntax dafür lautet:

Delphi-Quellcode:

var
  Objekt: TKlasse;
begin
  Objekt := TKlasse.Create;

Objekt ist jetzt ein Zeiger auf den Speicherbereich, in dem sich die Kopie der Klasse befindet. Natürlich muss man auch Speicher den man selber reserviert hat auch wieder frei geben. Dies macht man mit der Methode Free.

Ein vollständiges Beispiel:

Delphi-Quellcode:

var
  Objekt: TKlasse;
begin
  Objekt := TKlasse.Create;
  try
    // irgendwas machen mit dem Object
  finally
    Objekt.Free;
  end;

Das Konstrukt try-finally-end ist ein sogenannter Ressourcenschutzblock. Der Code-Block zwischen finally und end wir in jeden Fall ausgeführt, ob es nun zu einer Exception kommt oder nicht. So wird sicher gestellt, dass der Speicher für das Objekt auf alle Fälle wieder freigegeben wird.

Kommen wir zu deiner Frage. Was du gemacht hast ist folgendes. Du hast in den Vordruck des Formulares direkt reingeschrieben. Nur gibt es auf dem Vordruck eigentlich keinen Platz, um etwas reinzuschreiben, also hast du irgendwo auf einem belibiegen Stück Papier rumgekritzelt. Dass es bei dir trotzdem funktioniert hat, ist Zufall. Denn glücklicherweise hat sich kein anderer Teil deines Programmes diese Stück Papier reserviert, um es zu nutzen. Wäre das der Fall, hätte der andere Programmteil dein gekritzel überschrieben und wenn du das nächste mal dein Gekritzel lesen wolltest, hättest du für dich nur unverständliche Daten gelesen, mit denen du ichts anfangen kannst. Ein Absturz wäre die Folge gewesen.




Kommen wir zum Sender. Methoden einer Klasse haben als unsichtbaren Paramter immer den Self-Parameter. Dieser Self-Parameter ist nichts anderes als ein Zeiger auf die Instanz der Klasse selber. Damit kan nman innerhalb der Klasse auf Attribute und Methoden der eigenen Klasse zugreifen. Meist läßt an ihn aber weg, um Schreibarbeit zu sparen. Beispiel:

Code:

prozedure TKlasse.DoSomething([color=#00ff00]Self: TObject[/color]; i: Integer);
begin
  [color=#00ff00]Self[/color].FIndex := i;  // FIndex ist eine privates Attribut der Klasse.
end;

Der grüne Code-Teil ist der Sef-Paramter, der auch weggelassen werden kann.


Ich hoffe, meine Erklärung beantwortet deine Frage und du hast es verstanden.

Als weiterführende Literatur könnte ich dirmein Klassen Tutorial für Delphi empfehlen: http://delphitutorials.michael-puff.de

[3_of_8]

Weggelassen werden KANN?

Gibt eine solche Methodensignatur keinen "Redefined identifier"? :gruebel:

[Luckie]

Natürlich. Ich sollte erwähnen, dass der grüne Parameter der unsichtbare Self-Parameter ist, den Delphi automatisch ergänzt in der Parameterliste. Das Self im Prozedurrumpf, das ist optional. So, jetzt müssten alle Klarheitn beseitigt sein. ;)

[3_of_8]

Zitat:

Der grüne Code-Teil ist der Sef-Paramter, der auch weggelassen werden kann.

Diese Zeile hat mich irritiert, denn wenn er auch weggelassen werden kann, heißt das im Umkehrschluss, dass man ihn auch hinschreiben kann. ;)

[mkinzler]

Zitat:

Diese Zeile hat mich irritiert, denn wenn er auch weggelassen werden kann, heißt das im Umkehrschluss, dass man ihn auch hinschreiben kann. Wink

Sonst hätte Michael auch geschrieben: ...weggelassen werden muß.

[EccoBravo]

Hallo,

Vielen Dank für Eure reichhaltigen Antworten.
Natürlich - ich mache keinen Hehl daraus, daß mir so ziemlich sämtliche theoretischen Grundlagen in der Programmierung fehlen, und das noch nach 15 Jahren. Deshalb auch meine penetrante Fragerei in diesem Forum - vielen Dank für Eure Geduld !
Und das wil ich eben nur ein Autodidakt bin, ein Einzelkämpfer in meiner provinzialischen Wüste. Ich habe hier keinen, den ich vor Ort fragen kann und der nur annähernd auf meinem Gebiet arbeitet und bescheid weiß. Und deshalb kommen nach so langer Zeit solch dumme Trivialitäten zum Vorschein.
Bitte weiterhin um Verständnis!

Und nun kommen wieder meine Fragen:

1. Wenn dem mit dem Reservieren von Speicherplätzen so ist, warum muß nicht jede Single und jeder Integer mit Create genauso instanziert werden?
Warum denn da nicht, single ist ja auch nur ein Typ
und Var myZahl auch nur eine konkrete Kopie davon?

2. Try .. end ist ja ganz nett,
aber was, wenn ich mit mehreren Klassen gleichzeitig arbeite?

3. Create zum Instanziieren eines Formulares:
Es ist in meinen Programmen nicht immer erforderlich die Form.Create Methode auszufüllen,
diese Methode gibt es dann ja nicht im Code.
Ist dann das Formular nicht richtig als Objekt im Programm definiert?
Oder muß ich immer die Form.Create Methode ausfüllen, damit das Prigramm sauber geschrieben ist?

4. Wie verhält es sich mit der Instantiirung von dynamischen Arrays und Variablen, deren Länge erst zur Laufzeit des Programme bekannt wird?
wie:

Delphi-Quellcode:

type 
    TmyArray = array of single;
var 
    myArray:TmyArray;

implementation
    ...
    setlength(myArray,100);
    ...

oder ähnlichem.


Vielen Dank und Grüße eines ewig lernenden Dummie

E. B.