Parameter

Prozeduren ohne Parameter

Manchmal kommt es vor, daß verschiedene Prozeduren benötigt werden, die einander recht ähnlich sind.

Prozeduren

 Prozedurdefinition grüße_Sabine 
.----------------------------------. 
|Drucke "Hallo, Sabine!"           | 
|----------------------------------| 
|Drucke das Zeilenende             | 
'----------------------------------'

 Prozedurdefinition grüße_Andreas 
.----------------------------------. 
|Drucke "Hallo, Andreas!"          | 
|----------------------------------| 
|Drucke das Zeilenende             | 
'----------------------------------'

 Hauptprogramm 
.----------------------------------. 
|Prozeduraufruf grüße_Sabine       | 
|----------------------------------| 
|Prozeduraufruf grüße_Andreas      | 
'----------------------------------'

Ausgabe

Hallo Sabine! 
Hallo Andreas!

Man erkennt die Redundanz der wiederholten Verwendung des Druckkommandos. Besonders, wenn die Grußprozedur länger wird oder noch weitere Personen gegrüßt werden sollen, wird der Code vergrößert.

Prozeduren mit Eingangsparametern

Wenn man jedoch einen Teil einer Prozedur noch offen lassen kann, dann kann man eine allgemeine Grußprozedur ohne einen bestimmten Namen definieren und den Namen später einfügen.

Das geschieht durch Verwendung von Eingangsparametern.

Prozedur mit Parameter [Struktogramm]

  Prozedurdefinition grüße  
  Eingangsparameter name 
.----------------------------------. 
|Drucke "Hallo "                   | 
|----------------------------------| 
|Drucke name                       | 
|----------------------------------| 
|Drucke "!"                        | 
|----------------------------------| 
|Drucke das Zeilenende.            | 
'----------------------------------'

  Klient 
.----------------------------------. 
|Prozeduraufruf grüße              | 
|  Argument "Sabine"               | 
|----------------------------------| 
|Prozeduraufruf grüße              | 
|  Argument "Andreas"              | 
'----------------------------------'

Ausgabe

Hallo Sabine! 
Hallo Andreas!

Definiert man eine Methode mit einem Eingangsparameter (Parameter ), so kennzeichnet dieser einen Wert, der während der Niederschrift der Prozedur noch unbestimmt ist. Der Parameter ist also innerhalb der Prozedur ein Platzhalter.

Es ist dann möglich, diesen Wert erst später, beim Aufruf der Prozedur, als Eingangsargument (Argument) anzugeben. So kann die schädliche Redundanz vermindert werden. Wenn man den Parameter als eine Variable ansieht, so kann man sagen, daß diese beim Aufruf mit dem Wert des Arguments initialisiert wird.

Manchmal werden die Begriffe Parameter und Argument nicht so deutlich voneinander getrennt verwendet, wie in diesem Text und es wird zum Parameter Argument gesagt und umgekehrt. Das, was hier als Parameter bezeichnet wird, wird manchmal auch als Formalparameter  bezeichnet, während die Argumente manchmal auch als Aktualparameter  bezeichnet werden.

Aufruf einer Prozedur mit Argument [Kompassdiagramm]

  
              .-----------------------. 
              | Parameter   Prozedur  | 
------------->| name        grüße     |  
 "Sabine"     '-----------------------' 
 Argument                | 
                         V 
        Ausgabe "Hallo Sabine!" (Verhalten, Wirkung)

 
              .-----------------------. 
              | Parameter   Prozedur  | 
------------->| name        grüße     |  
 "Andreas"    '-----------------------' 
 Argument                | 
                         V 
        Ausgabe "Hallo Andreas!" (Verhalten, Wirkung)

Betrachtet man den zeitlichen Ablauf der Inkarnation und der Lebenszeiten des Parameters, so wird klar, daß der Parameter "name" der zweiten Inkarnation unabhängig vom Parameter "name" der ersten Inkarnation ist.

Zeitlicher Ablauf bei Aufruf einer Parameterprozedur

 | 
 |     Klient 
 |   .----------------------. 
 |   |                      | Erste Inkarnation 
 |   |                      | der Parameterprozedur 
 |   | gruesse( "Sabine" )  | "gruesse" 
 |   |              |       .-------------------. 
 |   |              |       | ( text parameter  | Anfang der 
 |   |              '--------> name )           | Lebenszeit von 
 |   |                      | Drucke "Hallo "   | "name" 
 |   |                      | Drucke name       |  
 |   |                      | Drucke "!"        |  
 |   |                      | Drucke Zeilenende |  
 |   |                      '-------------------' Ende der  
 |   |                      |                     Lebenszeit von 
 |   |                      |                     "name" 
 |   |                      | Zweite Inkarnation 
 |   |                      | der Parameterprozedur 
 |   | gruesse( "Andreas" ) | "gruesse" 
 |   |              |       .-------------------. 
 |   |              |       | ( text parameter  | Anfang der 
 |   |              '--------> name )           | Lebenszeit von 
 |   |                      | Drucke "Hallo "   | "name" 
 |   |                      | Drucke name       |  
 |   |                      | Drucke "!"        |  
 |   |                      | Drucke Zeilenende |  
 |   |                      '-------------------' Ende der  
 |   |                      |                     Lebenszeit von 
 |   |                      |                     "name" 
 |   |                      |  
 |   '----------------------' 
 | 
 V Zeit

Mehrere Eingangsparameter

Es ist auch mögliche mehrere Eingangsparameter zu verwenden, denen dann mehrere Argumente entsprechen müssen. Die Zuordnung von Argumenten zu Parametern erfolgt in den meisten Programmiersprachen durch die Reihenfolge oder seltener auch über eine explizite Benennung. Parameter und Argumente werden dann meistens durch Kommas getrennt.

Typtreue

Die Anzahl und der Datentyp der Argumente müssen mit der Anzahl und dem Datentyp der aufgerufenen Prozedur verträglich sein. Wenn die Typen nicht übereinstimmen, dann muß es zumindest möglich sein, den Typ jedes Arguments in den Typ des entsprechenden Parameters zu wandeln.

Aufruftyp

Gelegentlich wird auch nur der Typ eines Aufrufs benötigt und nicht dessen vollständige Definition. Zum Typ gehören folgende Angaben.

• Der Name des Aufrufs (also Name der Prozedur)
• Die Anzahl der Parameter
• Der Typ jedes Parameters

Dieser Aufruftyp wird auch als „Synopse“ (“synopsis ” oder “prototype ”) bezeichnen. Er wird beispielsweise benötigt, wenn geprüft werden soll, ob eine Prozedur mit den richtigen Argumenten aufgerufen wurde.

Zusatzaufwand durch Aufruf

Ein aufrufbarer Block einer übersetzten formalen Sprache wird oft in ein Maschinensprachen -Unterprogramm übersetzt. Der Aufruf eines aufrufbaren Blocks wird entsprechend oft in einen Unterprogrammaufruf der Maschinensprache übersetzt.

Die Verwaltung des Aufrufs  eines Unterprogramms bedeutet einen Zusatzaufwand an Laufzeit, die nicht verbraucht werden würde, wenn die Aktionen des Unterprogramms direkt an der Stelle des Aufrufs ohne  Unterprogrammaufruf erledigt werden würden. Die Übergabe der Kontrolle an das Unterprogramm und die Rückgabe der Kontrolle vom Unterprogramm kostet Laufzeit. In anderen Lektionen werden Parameter behandelt werden. Die Beschaffung und Freigabe von Speicher für Parameter und lokale Variablen, sowie die Initialisierung von Parametern kostet ebenfalls Laufzeit.

• Vom aufrufenden Programm wird die Kontrolle an das Unterprogramm übergeben.
• Beim Start des Unterprogramms muß Speicher  für eventuelle sogenannte Parameter beschafft werden.
• Der Parameterspeicher muß dann mit den Werten der Argumente initialisiert werden.
• Nach Erledigung der eigentlichen Arbeit des Unterprogramms muß der Parameterspeicher wieder freigegeben werden.
• Falls das Unterprogramm eine Funktion ist, muß die Rückgabe des Ergebnisses durchgeführt werden.
• Schließlich muß die Kontrolle wieder an das aufrufende Programm zurückgegeben werden.

Diese Vor- und Nachbereitung eines Unterprogrammaufrufes führt also zu einem Zusatzaufwand  an Laufzeit gegenüber der Durchführung derselben Rechnungen und Schritte direkt im aufrufenden Programm ohne Verwendung eines Unterprogramms. Andererseits bieten Unterprogramme viele Vorteile, so daß ihre Verwendung sehr wünschenswert ist.