Parameter (Informatik)

Grundidee und Zweck

Parameter, auch Übergabewerte genannt, sind Variablen, mit denen ein Computerprogramm auf die Verarbeitung bestimmter Werte oder Verarbeitungsweisen eingestellt wird. Sie werden außerhalb des eigentlichen Programmcodes festgelegt und besonders beim Aufruf von Unterprogrammen verwendet. Dadurch lässt sich ein Programm an unterschiedliche Situationen anpassen, ohne es neu zu erstellen oder zu ändern.

Bei der Programmerstellung muss festgelegt werden, welche Sachverhalte parametrisiert werden können. Das können beispielsweise Grenzwerte, Auswahlbedingungen, ein Datum, Texte oder Schalter wie „Prüfung X vornehmen – ja/nein“ sein. Fehlt beim Aufruf ein erforderlicher Wert, kann das Programm eine vorher festgelegte Standardannahme verwenden oder die Verarbeitung wegen fehlender Parameter abbrechen.

Parametrisierung ist ein Aspekt der Softwarearchitektur. Sie unterstützt nach ISO/IEC 9126 insbesondere Anpassbarkeit und Modifizierbarkeit, außerdem unter anderem Austauschbarkeit und Bedienbarkeit. Erwartbare Programmänderungen können vermieden und dadurch Aufwand sowie Fehlerrisiken verringert werden. Für Software in unterschiedlichen Umgebungen, insbesondere bei mandantenfähigen Systemen, ist Parametrisierung eine unabdingbare Voraussetzung. In der modularen Programmierung sind Parameter Bestandteil der Signatur von Funktionen, Methoden und Prozeduren und bilden ein wesentliches Kommunikationsmedium zwischen aufrufendem Programm und Unterprogramm. Auch Makros können als Subroutinen mit Parametern betrachtet werden.

Als Inputdaten unterscheiden sich Parameter von gewöhnlichen Eingabedaten: Sie gehören nicht zum eigentlichen Verarbeitungsbestand, sondern steuern die Anpassung oder Variante der Verarbeitung. Meist beziehen sie sich eindimensional auf eine konkrete Situation, häufig nur auf ein einzelnes Datenfeld. Sie werden oft über besondere Mechanismen des Betriebssystems oder der Programmiersprache interpretiert. Außer bei Unterprogrammen werden sie meist von Benutzern, Betreibern oder Mitarbeitern eines Rechenzentrums vorgegeben und bleiben oft längere Zeit unverändert.

Arten und Beispiele

Nach ihrem Einsatz unterscheidet man Installationsparameter, Konfigurationsparameter und Laufzeitparameter. Außerdem können Parameter als Schnittstelle zwischen aufrufendem Programm und Unterprogramm dienen.

Bei mehreren Parametern müssen diese eindeutig zugeordnet werden:

• Positionsparameter werden anhand ihrer Stellung erkannt. Ist der dritte Parameter die Startzeit, kann eine Folge wie „300;ABC;;;XYZ“ verwendet werden; der dritte und vierte Parameter sind dann nicht angegeben. Trennzeichen können beispielsweise Semikolon oder senkrechter Strich sein.
• Schlüsselwortparameter werden durch ein eindeutiges Schlüsselwort identifiziert, etwa „startzeit=13:30“. Sie sind meist unabhängig von der Position und können deshalb oft weggelassen werden.

Für beide Formen muss festgelegt werden, ob leere Parameter zulässig sind, ob dann eine leere Zeichenkette oder eine Standardannahme gilt und welches Format verwendet wird, beispielsweise „hh:mm“ mit jeweils zwei Stellen und einem Doppelpunkt.

Weitere Einteilungen betreffen die Quelle (intern von Programm zu Programm oder extern von außen), die Stabilität beziehungsweise Änderungshäufigkeit, den Typ und die Richtung des Informationsflusses. Parameter können Beträge, Grenzwerte, Zeitangaben oder Textkonstanten sein, aber auch funktionale Anweisungen wie „J/N“. Aufrufparameter fließen in ein Programm oder Unterprogramm, Rückgabeparameter zum aufrufenden Programm; auch ein bidirektionaler Informationsfluss ist möglich.

Typische Beispiele sind Mehrwertsteuersätze in Prozent, die Auswahl von Summen- oder Einzelzeilen in Listen, die Bezeichnung des Software-Eigentümers sowie Kreditbetrag, Zinssatz, Tilgungsbetrag und Tilgungsperiode bei der Berechnung eines Tilgungsplans. Bei einer Prüfziffernberechnung kann eine Kontonummer als Aufrufparameter und die Prüfziffer als Rückgabewert dienen.

Ein Beispiel ist ein Rechnungsprogramm. Ohne Parametrisierung könnte es fest verarbeiten: „Lese Rechnungen; verarbeite nur Rechnungen mit Status = ‚offen‘ und Rechnungsdatum < (heute ./. 1 Monat)“. Mit Parametern wie „Rechnungsdatum älter als“ und „offen_JN“ ließen sich Alter und Statusauswahl ändern. Zusätzlich könnten „ab Betrag = X“ sowie die Auswahl höherer, niedrigerer oder aller Beträge vorgesehen werden. Je nach Datenbanksystem kann die Auswahl bereits im Lesekommando des DBMS erfolgen oder erst im Programm nach dem Lesen.

Übergabemedien und Unterprogramme

Parameter können in Unterprogrammdefinitionen, Befehlszeilen, Job-Control-Anweisungen oder speziellen Parameterdateien stehen. Auch Registrierungsdatenbanken sowie betriebliche Datenbanken, Dateien und Tabellenverwaltungssysteme können solche Werte enthalten. Dialogprogramme können Parameter direkt über Bildschirm und Tastatur erfassen.

Bei Unterprogrammen werden formale Parameter in der Definition festgelegt. Sie sind Platzhalter für die Werte, die beim jeweiligen Aufruf übergeben werden. Die konkreten Werte heißen tatsächliche Parameter oder Argumente. Genau genommen bezieht sich „Parameter“ auf die Funktionsdefinition, „Argument“ auf den tatsächlichen Aufruf; in der Praxis werden beide Wörter oft synonym verwendet.

Beispiel in PASCAL oder Delphi:

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

Hier sind x und y formale Parameter. Aufrufe können beispielsweise „r1 := Radius(x1, y1)“ oder „Durchmesser := 2 * Radius(13, -2)“ lauten. Die formalen Parameter stellen benannten Speicherplatz ähnlich algebraischen Variablen bereit; Argumente sind die konkreten Werte oder Datenobjekte, die dort verwendet werden. Die Argumente müssen zu den formalen Definitionen zuweisungskompatibel sein.

Werden Datentypen formaler Parameter ausdrücklich angegeben, spricht man von Type-Hinting. In C, C++, Java und vielen weiteren Sprachen ist dies vorgeschrieben; Skriptsprachen bieten es häufig nicht an. Beispiele sind „float radius (float x, float y);“, die PHP-Definition „function radius($x, $y);“ ohne Type-Hinting und „function getData(PDO $db, $y);“, bei der der erste Parameter vom Typ PDO sein muss.

Unterprogramme verarbeiten übergebene Daten und liefern meist Rückgabewerte. Die Werte können auch Referenzen, Zeiger oder Speicheradressen sein. Im C++-Jargon bezeichnet „Type&“ eine Referenz und „Type*“ einen Zeiger. Eine Referenz darf im Gegensatz zu einem Zeiger nicht uninitialisiert oder leer sein; es muss immer ein gültiges Objekt des entsprechenden Typs übergeben werden. Referenzen auf Grunddatentypen wie „int&“ sind ebenfalls möglich.

Übergabearten und Parametermodi

Bei Wertparametern (call by value) wird der Wert eines Ausdrucks berechnet und gegebenenfalls kopiert. Der Ausdruck kann beispielsweise „2*x+1“ oder „sin(x)“ sein. Änderungen im Unterprogramm betreffen nur die Kopie und gehen nach dessen Ende verloren. Große Datenstrukturen, etwa Felder, müssen dabei kopiert werden.

Referenzparameter (call by reference) übergeben normalerweise die Speicheradresse des tatsächlichen Parameters. Das ist meist schnell; Änderungen bleiben nach dem Unterprogramm wirksam. Als Argumente sind nur Ausdrücke zulässig, deren Adresse berechnet werden kann, nicht etwa Konstanten.

Namensparameter (call by name) setzen den Namen des tatsächlichen Parameters an die Stelle des formalen Parameters ein. Der Ausdruck wird bei jeder Verwendung im Unterprogramm neu berechnet; zusätzlich wird eine Umgebung für die Bindungen freier Variablen übergeben. Beim Makro wird der formale Parameter dagegen textuell ersetzt, wobei Namenskonflikte mit lokalen Variablen möglich sind.

Wertergebnisparameter (call by value/return oder call by value and result) erzeugen zunächst eine Kopie und schreiben deren Inhalt am Ende zurück. Ergebnisparameter (call by result) verwenden eine lokal gültige, nicht initialisierte Variable, deren Wert beim Ende in die Speicherposition des Aufrufparameters kopiert wird. Call-by-Need ist eine Variante von Namensparametern, bei der jeder tatsächliche Parameter höchstens einmal ausgewertet wird. In Haskell gehört dies zur Lazy Evaluation. Moderne prozedurale Sprachen unterstützen meist Wert- und Referenzparameter, manchmal auch Wertergebnisparameter.

Ein Beispiel verdeutlicht die Unterschiede:

„proc test(x,y) { y = y + 1; x = 10 * x; }“, mit „a = 5“, „b = 4“ und „test(a, b)“.

Bei Wertparametern lautet die Ausgabe „5 4“; beim zweiten Aufruf „test(b, b)“ bleibt „b“ gleich 4. Bei Referenzparametern lautet die Ausgabe nach dem ersten Aufruf „50 5“, weil a mit 10 multipliziert und b zunächst um 1 erhöht wird. Beim Aufruf „test(b, b)“ verweisen x und y auf denselben Speicherbereich; b wird daher erst von 5 auf 6 und anschließend auf 60 verändert. Bei Wertergebnisparametern lautet die Ausgabe „50 5“ und danach „6“ oder „50“, weil beim zweiten Aufruf zwei Kopien von b zurückgeschrieben werden und die Reihenfolge entscheidend sein kann.

Einige Sprachen ordnen formalen Parametern zusätzlich Modi zu: „in“ bezeichnet reine Eingabe, „out“ reine Ausgabe und „inout“ Eingabe und Ausgabe. Der Modus legt fest, wie das Unterprogramm den Parameter verwenden darf.

Technische Übergabe und Referenzen

Je nach Rechnerarchitektur und Programmiersprache werden Parameter über Register oder über den Stack übergeben. Bei der Registerübergabe können festgelegte Register auf eine Adressliste mit den Parameteradressen zeigen; weitere Register enthalten beispielsweise Einsprung- und Rücksprungadresse.

Beim Stack-Verfahren unterscheidet man Programmspeicher für Maschinencode, dynamischen Speicher (Heap) für Daten und Stapelspeicher (Stack oder Aufrufstapel). Jeder Thread besitzt einen eigenen Stack. Dort liegen Rücksprungadressen, tatsächliche Parameter, lokale Variablen und Rückgabewerte. Der Stackpointer adressiert das untere Ende des Stackbereichs; ein Basepointer dient meist als Basisadresse für Parameter und Variablen. Die Speicherung folgt grundsätzlich dem Prinzip Last In – First Out (LIFO), obwohl auch beliebige Adressen innerhalb des Stacks erreichbar sind.

Die tatsächlichen Parameter werden üblicherweise von links nach rechts auf den Stack gelegt und bei Bedarf in das benötigte Format konvertiert. Beim Aufruf wird der Basepointer auf die erreichte Stackadresse gesetzt, sodass Parameter relativ zu dieser Basis auffindbar bleiben.

Bei vollständigen Datenstrukturen werden meist nicht die gesamten Werte, sondern Referenzen beziehungsweise Adressen übergeben. In C kann beispielsweise „void function(type* data)“ mit „function(&data)“ aufgerufen werden. Ohne „&“ entsteht bei bekanntem Funktionsprototyp ein Syntaxfehler. In C++ kann „void function(type& data)“ verwendet werden; dann wird die Adresse automatisch übergeben und der Aufruf lautet „function(data)“. Für den Aufrufer ist dabei nicht unmittelbar sichtbar, ob Wert oder Adresse übergeben wird.

Alternativ kann „void function(type data)“ eine Struktur vollständig kopieren. Das ist bei kleinen Strukturen sinnvoll oder wenn Änderungen am Original verhindert werden sollen, kann bei großen Strukturen aber den Stack überlasten. Über Referenzen können Unterprogramme Ergebnisse zurückschreiben, etwa „data->a = data->b * 2“. Mit „const“ wird in C++ beziehungsweise C ein referenzierter Bereich als konstant gekennzeichnet; ein Schreibzugriff führt dann zu einem Syntaxfehler. C prüft solche Zeigertypen weniger genau und kann je nach Übersetzer nur eine Warnung ausgeben. Java besitzt keine entsprechende const-Auszeichnung für Referenzparameter; Zugriffsschutz wird dort unter anderem durch private-Kapselung und geeignete Interfaces umgesetzt. In Java und C++ wird die Referenz auf Klassendaten bei Methoden implizit über den this-Zeiger übergeben.

Maschinenebene und Befehlszeile

Auf Maschinensprachniveau legt der Programmierer selbst fest, wie Parameter und Rücksprungadressen verwaltet werden. Bei geschachtelten Unterprogrammaufrufen muss die jeweilige Rücksprungadresse erhalten bleiben. Ein typischer Ablauf legt zunächst gegebenenfalls Platz für Rückgabewerte, dann Aufrufparameter, Rücksprungadresse und Basepointer auf den Stack. Beim Eintritt wird der Basepointer gesetzt, weiterer Platz für lokale Variablen reserviert und beim Ende werden Basepointer, Rücksprungadresse und Stackpointer wiederhergestellt. In Assembler muss dies selbst programmiert werden; C und C++ lassen es vom Übersetzer erzeugen, Java organisiert entsprechende Abläufe innerhalb der Virtuellen Maschine.

Für „float parabel(float x) { return x * x; }“ zeigt das 80x86-Beispiel beim Aufruf „float y = parabel(2.0F)“ unter anderem „push 40000000h“, „call parabel“, „add esp, 4“ und das Speichern des Ergebnisses in y. Im Unterprogramm werden mit „push ebp“, „mov ebp, esp“ und „sub esp, 40h“ Basepointer und 64 Byte Stackbereich eingerichtet; der Parameter wird relativ zu „ebp + 8“ geladen und mit „fmul“ multipliziert. Danach werden Register restauriert und mit „ret“ zurückgesprungen.

Ein weiteres Assemblerbeispiel für den ADSP-216x zeigt die C-Funktion „float set_floatExtend(_floatExtend* dst, float nVal)“. Der Zeiger „dst“ wird aus Register R4 in das Adressregister I4 übernommen, „nVal“ aus F8 nach PX geladen und der 40-Bit-Fließkommawert mit „dm(0,I4) = PX1“ und „dm(1,I4) = PX2“ auf zwei 32-Bit-Adressen gespeichert.

Befehlszeilenparameter werden beim Programmaufruf übergeben. Ein Windows-Beispiel ist „programm.exe -parameter -weiterer -xyz=(a|b) /usw“. Die Parameter können mit oder ohne Wert auftreten; Trennzeichen und Regeln hängen vom jeweiligen Programm ab. Unter Unix-artigen Systemen werden Optionen traditionell mit „-“ eingeleitet, etwa „ls -l -t /usr/bin /usr/local/bin“ oder zusammengefasst „ls -lt /usr/bin /usr/local/bin“. Mehrbuchstabige Optionen beginnen mit „--“. DOS verwendet traditionell „/“ und trennt Werte mit „=“; unter Windows kommen beide Stile vor. Befehlszeilenparameter können insbesondere geübten Benutzern eine schnelle Verarbeitung ermöglichen, beispielsweise das Laden, Konvertieren und Speichern beliebig vieler Bilder mit IrfanView.