Lazarus/Prozeduren, Funktionen und Bibliotheken: Unterschied zwischen den Versionen

Aus ZUM-Unterrichten
main>Peterdauscher
main>Peterdauscher
Keine Bearbeitungszusammenfassung
Zeile 64: Zeile 64:




{{kasten_blau|<source line start="30" highlight="1,11" lang="pascal">
procedure Hinweis(nachricht: string);
procedure Hinweis(nachricht: string);
begin
begin
Zeile 76: Zeile 77:
Hinweis('Eine frei gewählte Nachricht');
Hinweis('Eine frei gewählte Nachricht');
end;
end;
</source>}}
Unterscheiden tun sich die gelb markierten Zeilen: Bei der Definition der Prozedur "Hinweis" in Zeile 30 ist hinter dem Namen der Prozedur noch in Klammern eine Variable angegeben, die in diesem Fall den Namen <tt>nachricht </tt> trägt und vom Typ <tt>string</tt> ist.
Wird nun in Zeile 40 der neue Befehl <tt>Hinweis</tt> aufgerufen, und zwar mit der Zeichenkette <tt>'Eine frei gewählte Nachricht'</tt> in Klammern, so wird die Variable <tt>nachricht</tt> mit diesem Wert belegt.
Wird nun innerhalb der Prozedur wiederum der Befehl ShowMessage mit <tt>nachricht</tt> als Parameter aufgerufen, so erscheint tatsächlich die Meldung mit dem richtigen Text auf dem Bildschirm.
'''Wichtige Anmerkung:'''
Die Variable <tt>nachricht</tt> ist eine neue, eigenständige Variable. Beim Aufruf der Prozedur Hinweis wird ihr ein entsprechender Zeichenkettenwert zugewiesen. Wird dieser im Lauf der Prozedur verändert, so wirkt sich das auf das aufrufende Programm nicht aus.


=== Prozeduren mit Referenzparametern ===
=== Prozeduren mit Referenzparametern ===
Nun kann es sein, dass es der Zweck einer Prozedur sein soll, den Wert einer Variable im aufrufenden Programm aber tatsächlich zu ändern. Als Beispiel betrachten wir den (sehr sehr einfachen) Fall, bei dem der Wert einer Integer-Variable verdoppelt werden soll. Das Programm benötigt den Button <tt>Button1</tt> und das Edit-Feld <tt>Edit1</tt>. Der Vorspann mit Variablen usw. ist hier einfach einmal weggelassen.
{{kasten_blau|<source line start="30" highlight="1,10" lang="pascal">
procedure verdopple (zahl : integer);
begin
zahl:=zahl*2;
end;
procedure TForm1.Button1Click(Sender: TObject);
var zahlenwert : integer;
begin
zahlenwert:=StrToInt(Edit1.Text);
verdopple(zahlenwert);
Edit1.Text:=IntToStr(zahlenwert);
end;
</source>}}
Beim Ausprobieren merkt man: Das Beispiel funktioniert offensichtlich nicht. Der Inhalt des Edit-Feldes bleibt beim Drücken des Knopfes genau gleich.
Wir müssen das Programm leicht abändern, damit es funktioniert. Wir fügen in Zeile 30 vor der Variable <tt>zahl</tt>  das Schlüsselwort <tt>var</tt> ein. Das ist eigentlich ein wenig missverständlich, denn es soll bedeuten:
<tt>zahl</tt> ist '''keine''' eigenständige Variable sondern nur noch eine Art Spitzname für die Variable im Funktionsaufruf (man sagt auch: '''Referenz auf die Variable'''), in diesem Fall <tt>zahlenwert</tt>. Mit
<tt>zahl:=zahl*2</tt> wird jetzt in Wirklichkeit die Variable <tt>zahlenwert</tt> verdoppelt.
{{kasten_blau|<source line start="30" highlight="1,10" lang="pascal">
procedure verdopple (var zahl : integer);
begin
zahl:=zahl*2;
end;
procedure TForm1.Button1Click(Sender: TObject);
var zahlenwert : integer;
begin
zahlenwert:=StrToInt(Edit1.Text);
verdopple(zahlenwert);
Edit1.Text:=IntToStr(zahlenwert);
end;
</source>}}
Durch diese kleine Änderung funktioniert jetzt das Programm tadellos.




== Funktionen ==
== Funktionen ==
Im Grunde würden Prozeduren mit Wert- und Referenzparametern vollkommen ausreichern, um immer wiederkehrende Abläufe in selbstdefinierte Befehle zu verpacken (Informatiker sprechen gerne auch von "'''verkapseln'''").
So könnte man zum Beispiel eine Prozedur zum Berechnen des Quadrats von integer-Zahlen schreiben. Das Beispielprogramm benötigt die Komponenten <tt>Button1, Edit1, Edit2</tt>:
{{kasten_blau|<source line start="30" highlight="1,11" lang="pascal">
procedure quadrat(zahl : integer; var ergebnis: integer);
begin
ergebnis:=zahl*zahl;
end;
procedure TForm1.Button1Click(Sender: TObject);
var zahlenwert : integer;
    zahlenwertquadriert : integer;
begin
zahlenwert:=StrToInt(Edit1.Text);
quadrat(zahlenwert,zahlenwertquadriert);
Edit2.Text:=IntToStr(zahlenwertquadriert);
end;                           
</source>}}
Aber gerade im mathematischen Bereich ist das eher unüblich: außerdem muss man immer überlegen, welcher der beiden Parameter nun die eigentliche Zahl und welche das spätere Quadrat werden soll. Eleganter ist daher die folgende Schreibweise:
{{kasten_blau|<source line start="30" highlight="1,11" lang="pascal">
function quadrat(zahl : integer) : integer;
begin
quadrat:=zahl*zahl;
end;
procedure TForm1.Button1Click(Sender: TObject);
var zahlenwert : integer;
    zahlenwertquadriert : integer;
begin
zahlenwert:=StrToInt(Edit1.Text);
zahlenwertquadriert:=quadrat(zahlenwert);
Edit2.Text:=IntToStr(zahlenwertquadriert);
end;                           
</source>}}




{{Lazarus-Buch}}
{{Lazarus-Buch}}

Version vom 13. Januar 2013, 20:10 Uhr

Lazarus Logo (new).png

Lazarus-Buch


Prozeduren

Einfache Prozeduren

Wenn man Programme schreibt und immer mehr erweitert, so besteht die Gefahr, dass sie nicht nur immer größer sondern auch immer unübersichtlicher werden. Deshalb ist es sinnvoll, bestimmte, immer wiederkehrende Folgen von Befehlen mit einer bestimmten Bedeutung in einer Art selbst gebautem Befehl zusammenzufassen. Solche Befehle heißen auch Prozedur (engl.: procedure). Manche Leser werden den Sketch "Dinner for one" [1] kennen, bei dem Butler James immer wieder fragt: "Same procedure as last year, Miss Sophie" und Miss Sophie jedes Mal antwortet "Same procedure as every year, James" . James und Miss Sophie meinen genau dasselbe wie wir: einen fest geregelten Ablauf von Dingen.

Beispiel einer einfachen Prozedur

Ein sehr sehr einfaches Beispiel für eine Prozedur könnte ein Hinweis sein, der angezeigt werden soll, begleitet von einem hörbaren Signal. Das Programm benötigt lediglich einen Button mit dem Namen Button1.

Vorlage:Kasten blau


Man sieht, dass nach der Definition des eigenen Befehls (der Prozedur) "Hinweis" vollkommen genügt, diesen Befehl aufzurufen.

Prozeduren mit Wertparametern

Die oben gezeigte Prozedur tut immer genau das gleiche: Sie gibt das akustische Signal und den Hinweis "Sie haben den Knopf gedrückt". Häufig jedoch kommt es vor, das eine Prozedur zwar immer ähnliche, aber eben doch leicht verschiedene Dinge tun soll. So wäre es z.B. praktisch, wenn man den Hinweistext selbst immer wieder neu bestimmen könnte. Das funktioniert auch, wenn man der Prozedur einen so genannten Paramter mit auf den Weg gibt. Wir betrachten wiederum ein Beispiel:


Vorlage:Kasten blau

Unterscheiden tun sich die gelb markierten Zeilen: Bei der Definition der Prozedur "Hinweis" in Zeile 30 ist hinter dem Namen der Prozedur noch in Klammern eine Variable angegeben, die in diesem Fall den Namen nachricht trägt und vom Typ string ist. Wird nun in Zeile 40 der neue Befehl Hinweis aufgerufen, und zwar mit der Zeichenkette 'Eine frei gewählte Nachricht' in Klammern, so wird die Variable nachricht mit diesem Wert belegt. Wird nun innerhalb der Prozedur wiederum der Befehl ShowMessage mit nachricht als Parameter aufgerufen, so erscheint tatsächlich die Meldung mit dem richtigen Text auf dem Bildschirm.

Wichtige Anmerkung: Die Variable nachricht ist eine neue, eigenständige Variable. Beim Aufruf der Prozedur Hinweis wird ihr ein entsprechender Zeichenkettenwert zugewiesen. Wird dieser im Lauf der Prozedur verändert, so wirkt sich das auf das aufrufende Programm nicht aus.


Prozeduren mit Referenzparametern

Nun kann es sein, dass es der Zweck einer Prozedur sein soll, den Wert einer Variable im aufrufenden Programm aber tatsächlich zu ändern. Als Beispiel betrachten wir den (sehr sehr einfachen) Fall, bei dem der Wert einer Integer-Variable verdoppelt werden soll. Das Programm benötigt den Button Button1 und das Edit-Feld Edit1. Der Vorspann mit Variablen usw. ist hier einfach einmal weggelassen.


Vorlage:Kasten blau

Beim Ausprobieren merkt man: Das Beispiel funktioniert offensichtlich nicht. Der Inhalt des Edit-Feldes bleibt beim Drücken des Knopfes genau gleich.

Wir müssen das Programm leicht abändern, damit es funktioniert. Wir fügen in Zeile 30 vor der Variable zahl das Schlüsselwort var ein. Das ist eigentlich ein wenig missverständlich, denn es soll bedeuten: zahl ist keine eigenständige Variable sondern nur noch eine Art Spitzname für die Variable im Funktionsaufruf (man sagt auch: Referenz auf die Variable), in diesem Fall zahlenwert. Mit zahl:=zahl*2 wird jetzt in Wirklichkeit die Variable zahlenwert verdoppelt.

Vorlage:Kasten blau

Durch diese kleine Änderung funktioniert jetzt das Programm tadellos.


Funktionen

Im Grunde würden Prozeduren mit Wert- und Referenzparametern vollkommen ausreichern, um immer wiederkehrende Abläufe in selbstdefinierte Befehle zu verpacken (Informatiker sprechen gerne auch von "verkapseln").

So könnte man zum Beispiel eine Prozedur zum Berechnen des Quadrats von integer-Zahlen schreiben. Das Beispielprogramm benötigt die Komponenten Button1, Edit1, Edit2:


Vorlage:Kasten blau

Aber gerade im mathematischen Bereich ist das eher unüblich: außerdem muss man immer überlegen, welcher der beiden Parameter nun die eigentliche Zahl und welche das spätere Quadrat werden soll. Eleganter ist daher die folgende Schreibweise:

Vorlage:Kasten blau



Lazarus Logo (new).png

Lazarus-Buch

Abgerufen von „https://unterrichten.zum.de/index.php?title=Lazarus/Prozeduren,_Funktionen_und_Bibliotheken&oldid=96688“