[gelöst] Allgemein Fragen zu eigene Function u. Procedure

[Erwin]

Hallo.

Ich habe Heute eigene function und procedure erstelt. Was mir im groben auch gelungen ist. Nur im Detail habe ich da fragen. Ich habe darüber mal vor langer Zeit einiges gelesen. Und manches bekomme ich jetzt nicht mehr so ganz auf die Reihe. Vor allem wegen dern Bereich type in diesem Zusammenhang.

Bei function war es so, dass ich dies gar nicht oben, wo all die anderen procedure unter type deklariert werden, deklarieren konnte.
Interessanterweise war dies zum funktionieren der function auch nicht nötig. welche ich im gleichen Unit geschrieben habe, wo es dann auch gebraucht wird.

Bei procedure konnte ich es zusätzlich auch unter type deklarieren. Aber es war egal, ob es dort noch mal zusätzlich drin stand, oder nicht. Bin mir aber sicher, dass ich vor Jahren zu procedure gelesen habe, dass dies in type drin stehen muss. Da diese Beschreibungen aber meist komisch und über mehre Ecken waren ... also von weiteren Units die rede waren ... . Kann es sein, dass man so wohl function wie procedure nur dann unter type deklarieren muss, wenn diese wiederum auf einer anderen Unit sind, als auf jener, wo sie eh dann gebraucht werden?

procedure mache mir noch zusätzlichen ärger. Wolle damit versuchen, im zu Befehlen, "Button1.Caption := 'geht'" auszuführen. Aber beim kompilieren hieß es dann, dass Button1 nicht existiert? Und auch sonst erkannte der Compiler keine Komponete innerhalb meiner eigenen procedure?

Danke.

[Warf]

Das kommt auf den Dateityp an, Units sind unterteilt in den Interface Teil, dort wird alles definiert was nach außen sichtbar sein soll. Im Interface darf aber keine Funktionalität stehen.

Dann gibt es noch den Implementation Teil. Dort darfst du alles Definieren was nur Dateiintern sichtbar sein soll, und dort müssen auch die Funktionen die du im Interface definiert hast implementiert werden.

Beispiel:

Code: Alles auswählen

unit Name;
 
// Compilerswitches
 
interface
// Ab hier beginnt das interface
// uses ...
 
// Definitionen von Typen, Variablen, Konstanten, Funktionen, die global zulässig sind
// Konkret:
procedure Foo;
function Bar: Integer;
type TMyRec = record
//...
end;
var MyVar: Typ;
 
implementation
// Hier beginnt der implementation teil
// uses ...
 
// Definitionen von Typen, Variablen, Konstanten, Funktionen, die global zulässig sind
// Konkret:
procedure Foo;
begin
  // Implementierung der oben definierten Prozedur Foo
end;
 
function Bar: Integer;
begin
  // Implementierung der oben definierten Funktion Bar
end;
 
procedure FooBar;
begin
  // Prozedur FooBar, die nur in dieser Datei sichtbar ist
end;
 
// Dateiinterne Typdefinition
type TMyRec2 = record
//...
end;
// Dateiinterne Variablendefinition
var MyVar: Typ;
 
end.

Wichtig ist auch, die Position ist nur für Uses wichtig, uses muss sowohl im impementation als auch im interface Teil am Anfang stehen, Variablen, Funktionen und Typen kannst du in beliebiger Reihenfolge definieren wie du lustig bist, du kannst auch zu erst Funktion, Typ, Funktion und dann Variable Definieren.

Wichtig ist nur, du kannst immer nur das Nutzen was im Code über der aktuellen Zeile Steht

Code: Alles auswählen

procedure Bar;
begin
  MyVar := 3; // Fehler MyVar ist an dieser stelle noch nicht bekannt
end;
 
var MyVar: Integer;
 
function Foo: Integer;
begin
  MyVar := 5; // Funktioniert
end;

Im Definitionsteil von Funktionen darfst du sogar weitere Funktionen, Typen, Variablen und Konstanten Definieren:

Code: Alles auswählen

procedure Bar;
type myRec = record
 // ...
end;
procedure Foo(r: myRec);
begin
 //...
end;
var r: myRec;
begin
  Foo(r);
end;

procedure mache mir noch zusätzlichen ärger. Wolle damit versuchen, im zu Befehlen, "Button1.Caption := 'geht'" auszuführen. Aber beim kompilieren hieß es dann, dass Button1 nicht existiert? Und auch sonst erkannte der Compiler keine Komponete innerhalb meiner eigenen procedure?

Das liegt daran das Button1 ein element der Form Klasse ist. Entweder schreibst du deine Funkion als Klassen Methode von der Form klasse, oder verwendest die von lazarus erstellte Form Variable (das ist sehr unsauber)

[Erwin]

Danke für die Aufklärung.

Das Beispiel damals im Buch war ja eine Komponente die dann angezeigt wurde. Leider ist nicht genauer auf Details eingegangen worden.
Also procedure die nur was ausführen sollen, müssen somit nicht extra ins interface (type) aufgeliset werden, weil dafür Local ausreicht? Komisch dass manchmal auch eine function (zumindest unter Delphie mal erlebt) dort erscheint. Funktionen sind doch meist immer unsichtbar?
Und bei externen procedure und functionen reicht es also aus, wenn die betreffende Unit bei uses aufgelistet ist, so lange die procedure ebenfalls nicht Global, also für den Anwender angezeit werden soll?

Das mit den var wusste ich noch gar nicht. Ich habe mich immer gefragt, ob es dort richtig ist, oder zu weit oben oder gar zu weit unten ist? Also so lange es nicht weiter unten in der Unit gebraucht wird, ist der perfekte Platz nicht so wichtig. Gilt aber nur für Var? Nicht für Komponenten, procedure und functionen? Da spielt Reihenfolge nach wie vor keine Rolle? Bwz. sollte eher Alphabetsich sein, damit man es schneller findet, bzw. macht dies größtenteils Lazarus so?

Bei deinem vorletztem Beispiel schreibst Du von Funktion, aber im Code steht wiederum procedure?

Und beim letztem Beispiel, bzw Antwort umgekehrt? Die Meldung erschien bei mir bei einer procedure, nicht funktion.

[Warf]

Danke für die Aufklärung.

Das Beispiel damals im Buch war ja eine Komponente die dann angezeigt wurde. Leider ist nicht genauer auf Details eingegangen worden.
Also procedure die nur was ausführen sollen, müssen somit nicht extra ins interface (type) aufgeliset werden, weil dafür Local ausreicht? Komisch dass manchmal auch eine function (zumindest unter Delphie mal erlebt) dort erscheint. Funktionen sind doch meist immer unsichtbar?
Und bei externen procedure und functionen reicht es also aus, wenn die betreffende Unit bei uses aufgelistet ist, so lange die procedure ebenfalls nicht Global, also für den Anwender angezeit werden soll?

Das mit den var wusste ich noch gar nicht. Ich habe mich immer gefragt, ob es dort richtig ist, oder zu weit oben oder gar zu weit unten ist? Also so lange es nicht weiter unten in der Unit gebraucht wird, ist der perfekte Platz nicht so wichtig. Gilt aber nur für Var? Nicht für Komponenten, procedure und functionen? Da spielt Reihenfolge nach wie vor keine Rolle? Bwz. sollte eher Alphabetsich sein, damit man es schneller findet, bzw. macht dies größtenteils Lazarus so?

Bei deinem vorletztem Beispiel schreibst Du von Funktion, aber im Code steht wiederum procedure?

Und beim letztem Beispiel, bzw Antwort umgekehrt? Die Meldung erschien bei mir bei einer procedure, nicht funktion.

Funktionen nehme ich als Überbegriff für Funktionen und Prozeduren, da diese identische Eigenschaften haben.

Die Reihenfolge ist nur relevant wenn du in einer Funktion eine andere Verwenden willst, also willst du in Funktion Foo die Funktion Bar verwenden so muss Bar über Foo definiert sein.

Was du meinst mit den Funktionen die Dennoch definiert werden sind meist Klassenmethoden. Das sind Funktionen die auf einer Bestimmten Klasse agieren, z.B. FormLoad oder ButtonClick Events rufen Methoden auf. Diese müssen in der Klasse zu der sie gehören Definiert werden. Bei einer Formularanwendung erstellst du eine eigene Klasse, z.B. TForm1. Dieser Klasse fügst du dann verschiedene Methoden und Felder (Klassenvariablen z.B. Button1) hinzu. Jede Methode wird in einer Klasse entweder Public, Private, Protected oder Published definiert, und wird im implementation Teil dann implementiert:

Code: Alles auswählen

unit test;
 
// Compilerswitches
//uses
 
Type
  TMyClass = Class(ancestor) // z.B. TForm1 = class(TForm)
  private
    FMyFeld: Typ; // Feld
    proedure Foo;
  end;
 
implementation
 
procedure TMyClass.Foo; // TMyClass indiziert das die Methode zu der Klasse TMyClass gehört
begin
  // Implementierung
end;
 
end.

Durch die Zuweisung der Methoden zu einer Klasse können auch 2 Klassen den Selben Methodennamen in einer Datei haben.

In Methoden kannst du auf alle Felder, Methoden, Properties, etc. der Klasse (TMyClass in diesem Fall) Zugreifen. von außerhalb hat man nur eingeschränkte rechte.
So Kann man nur aus einer Klassen selben Types auf private Sachen Zugreifen, nur aus Abstammenden Klassen (und der eigenen) auf Protected (Vererbung geht hier aber etwas tief um es schnell zu erklären), und von überall auf Public Attribute zugreifen. Felder verhalten sich eigentlich genauso wie Variablen nur das diese nur innerhalb einer Klasseninstanz nutzbar sind

Klassen müssen afaik im Interface Definiert werden, und dürfen im Gegensatz zu anderen Typen nicht lokal definiert werden.

Aber das gehört alles zum Thema OOP, und das ist definitiv zu viel um es hier schnell zu erklären

[Erwin]

Bin mir nicht sicher, ob ich das wirklich verstanden habe?

Also Methoden wie Caption sind private. Und wenn man auf Private zugreifen will, muss man zum einem genau wissen, wie die Komponenten heißt. Also das was es unweigerlich Einzigartig macht. Wie zum Beispiel 'Form1.Button1.Caption'.
Habe ich nie so geschrieben ... naja, meist weißt es ja selbst dass Form1 noch dazu gehört. Hm.. sollte man aber vielleicht in Zukunft dazu schreiben, auch wenn dann alles voller wird?
Aber das allein reicht nicht. Die procedure braucht dazu vor allem noch die Erlaubnis, bzw. muss auch selbst einzigartig sein. Vor allem durch deklariation und/bzw. Zuweisung zu einer Classe. Denn ab dann ist der Austausch untereinander (inklusive eigener prozedure) immer einzigartig, und es kann somit keine Zuweisungs-Fehler passieren?

[Warf]

Am besten liest du dir mal was zum Thema OOP durch, dieses PDF habe ich dazu auf die schnelle gefunden

[Erwin]

Danke, lese ich mir vielleicht mal durch. Aber leider nicht Heute; Kopfweh. Und das schon bevor man aufsteht ... .

Habe inwzischen ein wenig getestet, mit einer Variable Button1. Damit kommt Eigene precedure klar, für die zu den Komponenten zugeörigen kennen dies wiederum nicht, oder wollen es nicht nutzen, um es mal einfach auszudrücken.

Wenn ich mir so Deine Besipiele ansehe ... Kann es sein, dass es standard ist, bzw. besondes Sinnvoll, eigene procedure und auch 'var'-Zuweisungen noch zwischen Interface- und Implementation-Teil, nach dem Abschließen (end;) des Type-Teils zu schreiben? Glaube nämlich, ich habe damals unter Delphie erst im Imlementations-Teil damit angefangen, so weit ich mich erinnere, bzw. es so gelernt?!? Jedenfalls ist sicher, dass ich es es unter Lazarus so gemacht habe.

Und noch was stellte ich inzwischen fest. Nämlich folgende Zuweisungs-Möglichkeit:

Code: Alles auswählen

 
var
  Name, Vorname: String;
  Alter, Groese: Integer;
  Lebtnoch: Boolean;
 

Was mich dabei rritiert bzw. neu ist: Dsa 'var' steht sozusagen als Überschrift dort. Aber nicht vor jeder Zeite? Auch das hatte ich nämlich anders gelernt. Dass es vor jeder Zeile stehen muss. Funktionieren tut mein Beispiel da oben auf alle Fälle. Aber ist das auch ein sauberer Schreib-/Codierungs-Stil?

[Warf]

Danke, lese ich mir vielleicht mal durch. Aber leider nicht Heute; Kopfweh. Und das schon bevor man aufsteht ... .

Habe inwzischen ein wenig getestet, mit einer Variable Button1. Damit kommt Eigene precedure klar, für die zu den Komponenten zugeörigen kennen dies wiederum nicht, oder wollen es nicht nutzen, um es mal einfach auszudrücken.

Wenn ich mir so Deine Besipiele ansehe ... Kann es sein, dass es standard ist, bzw. besondes Sinnvoll, eigene procedure und auch 'var'-Zuweisungen noch zwischen Interface- und Implementation-Teil, nach dem Abschließen (end;) des Type-Teils zu schreiben? Glaube nämlich, ich habe damals unter Delphie erst im Imlementations-Teil damit angefangen, so weit ich mich erinnere, bzw. es so gelernt?!? Jedenfalls ist sicher, dass ich es es unter Lazarus so gemacht habe.

Und noch was stellte ich inzwischen fest. Nämlich folgende Zuweisungs-Möglichkeit:

Code: Alles auswählen

 
var
  Name, Vorname: String;
  Alter, Groese: Integer;
  Lebtnoch: Boolean;
 

Was mich dabei rritiert bzw. neu ist: Dsa 'var' steht sozusagen als Überschrift dort. Aber nicht vor jeder Zeite? Auch das hatte ich nämlich anders gelernt. Dass es vor jeder Zeile stehen muss. Funktionieren tut mein Beispiel da oben auf alle Fälle. Aber ist das auch ein sauberer Schreib-/Codierungs-Stil?

Das sind die Methoden der Form Klasse, die ergeben dann sinn wenn sie etwas mit der Klasse selbst zu tun haben, aber wie gesagt, du wirst das nicht verstehen können bis du OOP verstehst, ohne das wirst du generell mit dem LCL framework nicht so weit kommen, da die gesamte LCL auf OOP basiert