Zur Themenübersicht     

Syntax bei Prozeduren und Funktionen

Am Beispiel des ggt (größten gemeinsamen Teilers) zweier Zahlen. Zu diesem Beispiel gehört das Delphi-Projekt   ggt_prozedur_und_funktion'

1. Prozeduren, welche Ergebnisse liefern sollen:

Noch einmal zur Erinnerung: Wir interpretieren den Aufruf einer Prozedur als Erteilung eines Auftrages. Die für die Erfüllung eines Auftrages benötigten Daten werden bei der Auftragserteilung über Parameter weitergegeben. Gehört zur Erfüllung eines Auftrages die Berechnung neuer Daten, was wir jetzt voraussetzen, werden auch diese Daten über Parameter ausgetauscht.

1.1 Syntax (Schreibweise) des Prozeduraufrufes

Beispiel für die Syntax von Prozeduraufrufen 




Dies ist der Prozeduraufruf
der Prozedur
berechneggt -------------------------->

Auftraggeber ist die Prozedur
TForm_ggt.BtggT_prozedurClick 

procedure TForm_ggt.BtggT_prozedurClick(Sender: TObject);
var a,b,ergebnis:Integer;
begin
   a := StrToInt (EdA.text);
   b := StrToInt (EdB.text);

   berechneggt(a,b,ergebnis); 

   Edggt.text := IntToStr(ergebnis);
end;

Der Aufruf einer Prozedur steht immer für sich allein, er kann z.B. nicht Teil eines Rechenausdruckes sein. Beim Prozeduraufruf stehen sowohl die Eingabedaten, wie auch die Ausgabedaten in der Parameterliste hinter dem Prozedurnamen.(Natürlich ohne Angabe des Datentyps bzw. der Objektklasse).

1.2 Syntax (Schreibweise) bei der Prozedurdeklaration:

Beispiel für die Syntax von Prozeduraufrufen 
Dieser Teil einer Unit heißt
Prozedurdeklaration. Auch hier
gibt es eine Parameterliste
hinter dem Prozedurnamen. Bei
den hier auftretenden formalen
Parametern muss der Datentyp
bzw. die Objektklasse angegeben
werden, der die aktuellen
Parameter entstammen müssen. 
Parameter, welche Ausgabedaten 
liefern, müssen mit dem Schlüssel-
wort VAR gekennzeichnet werden.

procedure berechneggt (alok,blok :Integer;
                       var ggtlok:Integer);
var rest :Integer;
begin
   repeat
      rest := alok mod blok;
      alok := blok;
      blok := rest
   until rest = 0;
   ggtlok := alok
end;

Noch einmal zur Sichtweise:

Bei der Prozedurdeklaration betrachten wir die Prozedur von innen. Wir kümmern uns darum, wie sie arbeitet.

Beim Prozeduraufruf betrachten wir die Prozedur von außen. Wir kümmern und darum, was sie leistet.

2.1 Ergebnisse liefern mittels Funktionen:

Wenn eine Prozedur nur ein einziges Ergebnis liefert (nur dann), ist es möglich eine andere Schreibweise - die einer Funktion - zu wählen. Wir sprechen dann nicht von der Erteilung eines Auftrages sondern von einer Anfrage. Die Anfrage wird durch den Funktionsaufruf gestellt. Die Funktion liefert dann die Antwort. Die Antwort wird verwendet, indem der Funktionsname als Teil eines Rechenausdrucks (allgemeiner eines Terms) benutzt wird:

Beispiel für die Syntax von Funktionsaufrufen 





Hier steht der Funktionsname
rechts vom Zuweisungsoperator












Hier wird der Funktionsname
wie eine Variable benutzt.

procedure TForm_ggt.BtggT_fktClick(Sender: TObject);
var a,b,ergebnis:Integer;
begin
   a := StrToInt (EdA.text);
   b := StrToInt (EdB.text);
   
   ergebnis := ggt(a,b); 
   
   Edggt.text := IntToStr(ergebnis);
end;

oder noch kürzer wäre:

procedure TForm_ggt.BtggT_fktClick(Sender: TObject);
var a,b:Integer;
begin
   a := StrToInt (EdA.text);
   b := StrToInt (EdB.text);
   
   Edggt.text := IntToStr(ggt(a,b))

end;

2.2. Deklaration von Funktionen:

Nun wieder zur Festlegung, wie eine Funktion die Antwort auf eine Anfrage ermittelt, zur Deklaration. Auch bei der Deklaration muss eine besondere Schreibweise beachtet werden: Der Ergebnistyp ist hinter der Parameterliste hinter einem Doppelpunkt anzugeben. Innerhalb des Funktionsrumpfes kann dann der Name der Funktion - oder das Schlüsselwort result - wie ein formaler Ausgabeparameter benutzt werden:

 
Beispiel für die Syntax von Funktionsaufrufen 
Hier liefert die Funktion 
einen Integer-Wert zurück






Hier wird der Funktionsname  ---> 
wir ein formaler Ausgabeparameter
benutzt. 

function ggt (alok,blok :Integer):Integer;
var rest :Integer;
begin
   repeat
      rest := alok mod blok;
      alok := blok;
      blok := rest
   until rest = 0;
   ggt := alok
// möglich wäre auch:
// result := alok
end;

Hier als kleines Schmankerl noch eine rekursive Funktionsdeklaration, bei der die Funktion sich selbst aufruft:

 
Beispiel für die Deklaration einer rekursiven Funktion 
function ggt (alok,blok :Integer) : Integer;
begin
    if (alok mod blok) = 0
       then  result := blok
       else  result := ggt ( blok, alok mod blok)
end;

Zur Themenübersicht  
Zum Seitenanfang 
Zur vorigen Seite         Zur nächsten Seite  

    © 2000 LK 12 If und G. Kubitz  Hannah-Arendt-Gymnasium, Lengerich