Funktionsparameter

Ein Parameter ist in der Informatik ein veränderliches Element eines Programms oder Unterprogramms, das bei der Definition des Unterprogramms formal angelegt (formaler Parameter) und beim Aufruf des Unterprogramms für jeweils diesen einen Aufruf auf einen konkreten Wert gesetzt wird (tatsächlicher Parameter) oder aber ein „Schalter“, der Abläufe im Programm steuert (etwa der Kommandozeilenparameter).

Unterschiedliche Parameter-Begriffe

Parameter werden in unterschiedlichen Funktionen in der Informatik verwendet:

• als Installationsparameter bei der Installation einer Software
• als Konfigurationsparameter, die das Verhalten der Software steuern
• als Laufzeitparameter, um die Software zur Laufzeit beeinflussen zu können.

Bei der Übergabe mehrerer Parameter ist es wichtig zu wissen, welche Bedeutung der einzelne Parameter hat. Hierzu gibt es zwei Erkennungsmethoden:

• Positionsparameter erkennt man an der Position ihrer Übergabe. Beispiel: Der 3. Parameter ist die Startzeit.
• Schlüsselwortparameter erkennt man am Schlüsselwort. Beispiel: „starttime = 13:30“.

Formaler Parameter

Die formalen Parameter werden bei der Deklaration eines Unterprogramms in einer Programmiersprache normalerweise als Argumente hinter dem definierenden Funktionsnamen angegeben. Damit ist es möglich, die Funktionsvorschrift so anzugeben, dass nicht bekannt sein muss, mit welchen konkreten Werten gerechnet werden soll. Oft erfordert die Angabe eines formalen Parameters nur die Angabe des verwendeten Datentyps.

Beispiel: Unterprogrammdeklaration in der Programmiersprache PASCAL bzw. Delphi mit x und y als formalem Parameter

FUNCTION Radius(x, y : REAL) : REAL; 
 BEGIN 
  Radius := SQRT( x*x + y*y ) 
 END;

Die formalen Parameter, hier x und y, sind "Platzhalter" für die tatsächlichen Parameter.

Tatsächlicher Parameter

Während des tatsächlichen Unterprogrammaufrufs werden durch die Parameterübergabe die tatsächlichen Parameter an die Funktion übergeben und definieren bei der Ausführung die Bedeutung der abstrakten formalen Parameter durch konkrete Werte oder konkrete Variablen. Im Deutschen findet man auch die Bezeichnung aktueller Parameter, die durch falsche Übersetzung des englischen Ausdrucks actual parameter (tatsächlicher Parameter) zustande kommt. Die Art der Übergabe ist von Programmiersprache zu Programmiersprache verschieden. Die Sprache Fortran verwendet beim Übersetzen festgelegte Speicheradressen für jedes Unterprogramm. Sprachen wie Pascal oder C verwenden den Stack oder Prozessorregister zur Parameterübergabe.

Beispiel: Aufruf des Unterprogramms mit verschiedenen tatsächlichen Parametern

r1 := Radius(x1, y1);               -- tatsächliche Parameter x := x1 und y := y1
Durchmesser := 2 * Radius(13, -2);  -- tatsächliche Parameter x := 13 und y := -2

Type-Hinting

Werden die Datentypen der formalen Parameter vorgegeben, wie im obigen Beispiel, spricht man von Type-Hinting. Type-Hinting ist in vielen Programmiersprachen (C, C++, Java, und einige mehr) Pflicht (das Auslassen führt zu einem Syntaxfehler), während Skriptsprachen häufig keine Möglichkeit bieten Type-Hinting zu verwenden.

• Ein Beispiel aus C++:

float radius(float x, float y);

• Ein Beispiel aus PHP:

function radius($x, $y);

Parameterübergabe

Es gibt unterschiedliche Methoden, wie die formalen Parameter während der Parameterübergabe durch die tatsächlichen Parameter ersetzt werden:

1. Bei Wertparametern (call by value) wird der Wert eines Ausdrucks berechnet und gegebenenfalls eine Kopie des Ergebnisses erzeugt. Dieses wird an Stelle des formalen Parameters verwendet. Die tatsächlichen Parameter können beliebige Ausdrücke wie 2*X+1, sin(x) sein. Etwaige Änderungen der Parameter im Unterprogramm werden nur in der Kopie durchgeführt und gehen bei Abschluss des Unterprogramms verloren. Große Datenstrukturen wie Felder werden bei der Übergabe kopiert, was unerwünscht sein kann.
2. Referenzparameter (call by reference) übergeben eine Referenz (normalerweise die Speicheradresse) des tatsächlichen Parameters. Dies ist in der Regel sehr schnell. Änderungen bleiben auch nach Abschluss des Unterprogramms wirksam. Tatsächliche Parameter können nur Ausdrücke sein, deren Adresse berechnet werden kann, also z. B. keine Konstanten.
3. Namensparameter (call by name) setzen den Name des tatsächlichen Parameters an Stelle des formalen Parameters ein. Dies kann auch mehrfach geschehen. Zusammen mit dem tatsächlichen Parameter wird eine Umgebung übergeben, welche die Bindungen der freien Variablen, welche im tatsächlichen Parameter vorkommen, angibt. Der Unterschied zu Wertparametern ist, dass der Ausdruck jedes Mal berechnet wird, wenn der Parameter in der aufgerufenen Funktion benutzt wird.

In einem Makro wird der formale Parameter textuell durch den tatsächlichen Parameter ersetzt. Der Unterschied zu Namensparametern besteht darin, dass Namenskonflikte in Kauf genommen werden. Kommt in einem tatsächlichen Parameter eine Variable vor, welche den gleichen Namen wie eine lokale Variable besitzt, so wird bei der Makroexpansion die lokale Variable verwendet.

1. Wertergebnisparameter (call by value/return oder call by value and result) erzeugen wie Wertparameter beim Aufruf zunächst eine Kopie des tatsächlichen Parameters. Bei Unterprogrammende wird der Inhalt des Parameters jedoch zurückgeschrieben. Dieser Parameterübergabemechanismus kann bei nebenläufigen Programmen eine andere Wirkung als die Verwendung von Referenzparametern haben, da während der Ausführungszeit des Unterprogramms ein anderer Thread auf die Variable in der aufrufenden Prozedur zugreifen kann.
2. Ergebnisparameter (call by result) erstellen eine lokal gültige, nicht initialisierte Variable als Parameter. Dieser Variable wird während der Abarbeitung des Unterprogramms ein Wert zugewiesen und bei Unterprogrammende in die Speicherposition des Aufrufsparameters kopiert, sodass dieser überschrieben wird.
3. Call-by-Need ist eine Variante von Namensparametern, bei der jeder übergebene tatsächliche Parameter maximal einmal ausgewertet wird. Wird ein tatsächlicher Parameter ausgewertet, so werden alle Vorkommen des formalen Parameters durch den erhaltenen Wert ersetzt. In Haskell ist call-by-need Teil der Lazy Evaluation.

Moderne, prozedurale Programmiersprachen unterstützen in der Regel Wertparameter und Referenzparameter, manchmal auch Wertergebnisparameter.

Beispiel für verschiedene Parameterübergaben

proc test(a,b)
{ 
    b = b + 1;
    a = 10 * a;
}

a = 5;
b = 4;
test(a ,a);
print(a, b);
test(b, b);
print(b);

Ausgabe bei Wertparametern (call by value)

5 4
4

Erklärung: Es wird durch die Aufrufe von test keine Veränderung an den Variablen a und b durchgeführt, sodass die Variablen jeweils nach Beendung des Unterprogramms ihren ursprünglichen Wert beibehalten.

Ausgabe bei Referenzparametern (call by reference)

60 4
50

Erklärung: Bei der ersten Abarbeitung von test, aufgerufen in Zeile 9, verweisen sowohl die lokale Variable a als auch b auf den Speicherbereich von a, da a für beide Parameter angegeben wurde. Daher werden alle Veränderungen, die in test an a und b ausgeführt werden, im gleichen Speicherbereich ausgeführt. a hatte vor diesem Aufruf den Wert 5, wird in Zeile 3 um 1 erhöht und anschließend wird in Zeile 4 dieser Wert mit 10 multipliziert; also steht an der Speicherstelle nun der Wert 60. Zurück im Hauptprogramm weist a dann auf die Speicherstelle, an der die soeben berechnete 60 steht, also wird 60 in Zeile 9 für a ausgegeben, b wurde nicht geändert.

Nach dem gleichen Prinzip funktioniert die zweite Abarbeitung von test, aufgerufen in Zeile 11. Es verweisen sowohl die lokale Variable a als auch b auf den Speicherbereich von b, da b für beide Parameter angegeben wurde. Daher werden alle Veränderungen, die in test an a und b ausgeführt werden, im gleichen Speicherbereich ausgeführt. b hatte vor diesem Aufruf den Wert 4, wird in Zeile 3 um 1 erhöht und anschließend wird in Zeile 4 dieser Wert mit 10 multipliziert; also steht an der Speicherstelle nun der Wert 50. Zurück im Hauptprogramm weist b dann auf die Speicherstelle, an der die soeben berechnete 50 steht, also wird 50 in Zeile 12 für b ausgegeben.

Ausgabe bei Wertergebnisparametern (call by value and result)

50 5
6 oder 50

Erklärung: Beim zweiten Aufruf von test werden zwei Kopien von b erstellt, auf die a und b innerhalb von test zeigen. a hat bei Beendung des Unterprogramms den Wert 50, b hat den Wert 6. Je nach dem, welcher Wert zuerst in das ursprüngliche b zurück gespeichert wird, kann das Ergebnis variieren.

Befehlszeilenparameter

Zudem besteht bei vielen gängigen Programmen für alle gängigen Betriebssysteme die Möglichkeit, Parameter in der Befehlszeile zu übergeben, die dann beim Aufrufen bearbeitet werden.

Beispiel: Fiktiver Programmaufruf über die Befehlszeile unter Windows

programm.exe -parameter -weiterer -xyz=(a|b) /usw

Hiermit würde programm.exe mit den Parametern „parameter“, „weiterer“, „xyz=(a|b)“ und „usw“ aufgerufen werden. Parameter werden also mit oder ohne Wertangabe verwendet, wobei die Wertangabe dem Namen mit Leerraum, mit Sonderzeichen wie „=“ oder gar nicht abgegrenzt angehängt werden. Je nachdem, welches Programm verwendet wird, stehen verschiedene Parameter zur Verfügung; je nach Programm haben gleich benannte Parameter im Allgemeinen unterschiedliche Auswirkungen. Auch die formalen Regeln zur Angabe sind vom Programm abhängig; dass, wie im Beispiel, mehrere unterschiedliche Trennzeichen verwendet werden, ist zwar unüblich und dient nur der Demonstration, aber viele Programme bieten durchaus flexible Möglichkeiten.

Unter UNIX-artigen Systemen werden Parameter traditionell mit einzelnen Buchstaben angegeben und mit „-“ eingeleitet, wenn es sich um Optionen oder Schalter handelt, die aus einer für das jeweilige Programm feststehenden Menge ausgewählt werden können; dagegen werden Parameter nicht besonders eingeleitet, wenn es sich um Dateinamen und ähnliche freie Angaben handelt. Die Abgrenzung voneinander geschieht erforderlichenfalls durch Leerraum. Beispiel: „ls -l -t /usr/bin /usr/local/bin“ oder gleichbedeutend „ls -lt /usr/bin /usr/local/bin“. Bei Programme, die sowohl einbuchstabige als auch mehrbuchstabige Optionen annehmen, sind letztere mit „--“ einzuleiten.

Unter DOS (in Tradition von OpenVMS) wird traditionell „/“ an Stelle des „-“ verwendet und Werte von Parameternamen mit „=“ abgetrennt. Unter Windows sind beide Stile anzutreffen.

Allgemein kann man sagen, dass man bei der Verwendung von Befehlszeilenparametern oft schneller zu Ergebnissen kommt, als durch andere Bedienmöglichkeiten wie Dialogfenster in einer GUI. So ist es mit IrfanView zum Beispiel ein Leichtes, mittels dreier Parameter beliebig viele Bilder zu laden, zu konvertieren und in einem anderen Format zu speichern.