Parameter (Informatik)

Parameter sind in der Informatik Variablen, über die ein Computerprogramm oder Unterprogramm, für einen Aufruf gültig, auf bestimmte Werte "eingestellt" werden kann. Diese Einstellungen werden bei der Verarbeitung berücksichtigt und beeinflussen damit meist auch die Ergebnisse des Programms. Parameter sind also programmextern gesetzte Einflussfaktoren.

Durch Parametrisierung können Programme in ihrer Anwendung flexibilisiert werden, ohne dass das Programm dazu neu erstellt werden muss. Welche Werte eingestellt werden können, muss bei der Erstellung von Programmen berücksichtigt werden. Parameter können z. B. bestimmte Grenzwerte oder Auswahlbedingungen (für Beträge, ein Datum etc.) oder zu verwendende Texte sein oder auch das "Was" und das "Wie" der Verarbeitung steuern (z. B. Prüfung X vornehmen - J/N).

Wird beim Aufruf des Programms nicht für jeden Parameter ein Argument übergeben, kann das Programm (je nach Implementierung) beim Erstellen des Programms festgelegte Werte verwenden oder aber die Verarbeitung abbrechen.

Zweck von Parametern

Prinzip der Parametrisierung

• In der modularen Programmierung sind die Schnittstellen zwischen den einzelnen Modulen implementierungsimmanent 'Parameter'. Sie sind das wesentliche Kommunikationsmedium zwischen aufrufendem und aufgerufenem Programm, Informationen können in beide Richtungen fließen.
• Darüber hinaus ist Parametrisierung ein Aspekt der Softwarearchitektur: So implementierte Software kann den Qualitätskriterien für Software nach ISO/IEC 9126 vor allem in den Punkten Anpassbarkeit und Modifizierbarkeit entsprechen, unterstützt aber auch die Anforderungen Austauschbarkeit, Bedienbarkeit und andere.
• Durch Parametrisierung können Programmänderungen für im Voraus erwartbare Situationen vermieden und damit Aufwand und Fehlerrisiken (durch Programmänderungen) minimiert werden.
• Für Programmeinsätze in vielen unterschiedlichen Umgebungen (Mandantenfähigkeit) ist die Parametrisierung unabdingbare Voraussetzung. Vor allem bei Systemprogrammen wird sie deshalb in der Regel sehr umfassend praktiziert (mindestens über Konfigurationsparameter).

Parameter sind aus Sicht des Systembegriffs Inputdaten; sie unterscheiden sich jedoch von normalen Eingabedaten z. B. wie folgt:

• Parameterdaten gehören nicht zum eigentlichen Verarbeitungszweck des Programms, sondern sie sollen - soweit dies bei der Implementierung berücksichtigt wurde - das Programm auf individuelle Werte / Informationen und / oder mögliche Varianten der Verarbeitung einstellen.
• Parameterdaten sind i. d. R. eindimensional, d. h., es gibt keinen Objektbegriff und keine Objektmengen (wie z. B. bei Kunden- oder Produktdaten).
• Sie werden vom Programm i. d. R. nicht einfach 'gelesen' wie andere Dateien, sondern häufig über spezielle Mechanismen (des Betriebssystems oder der Programmiersprache) interpretiert.
• Sie werden meist durch die Benutzer eingestellt, die für den technischen Ablauf des Programms verantwortlich sind, z. B. Mitarbeiter des Rechenzentrums.
• Sie werden in vielen Fällen über längere Zeit nicht verändert.

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 Verwendung mehrerer Parameter ist es wichtig, die einzelnen Parameter identifizieren und unterscheiden zu können. Hierzu gibt es zwei Erkennungsmethoden:

Positionsparameter

werden bei der Übergabe anhand ihrer Position zugewiesen. Beispiel: Der dritte Parameter ist die Startzeit.

Schlüsselwortparameter

werden bei der Übergabe mit einem eindeutigen Schlüsselwort gekennzeichnet und sind somit unabhängig von ihrer Position identifizierbar. Beispiel: „startzeit = 13:30“.

Für beide Varianten muss festgelegt sein, wie die Parameter voneinander getrennt werden, z. B. durch fest definierte Längen (i. d. R. nur bei Positionsparametern) oder durch Semikolons, und in welchem Format sie erwartet werden; im Beispiel: "hh:mm", jeweils 2 Stellen, getrennt durch ":".

Weiterhin lassen sich Parameter unterscheiden nach:

Quelle der Parameter

Intern = von Programm zu (Unter-) Programm wirksam; Extern = von außen, z. B. durch Benutzer gesetzte Parameter

Stabilität / Änderungshäufigkeit

Wird der Parameter häufig oder fast immer neu gesetzt oder wird er selten verändert?

Art / Typ der Parameter

Variablen wie Betragsfelder (z. B. Grenzwerte), Zeitangaben (Tagesdatum), Textkonstanten etc. oder funktional wirkende Anweisungen wie 'nur fehlerhafte Daten auflisten', 'nur protokollieren, nicht speichern' etc.

Richtung des Informationsflusses

Aufrufparameter (in Richtung Programm / Unterprogramm) oder Rückgabeparameter (in Richtung aufrufendes Programm; nur bei Unterprogrammen); auch bidirektional ist möglich (Aufruf / Rückgabe)

Beispiele für Parameter

• Mehrwertsteuersätze in Prozent (bei betriebswirtschaftlichen Anwendungen)
• Sollen in Listen nur Summen- oder auch Einzelzeilen ausgegeben werden? (steuert den Detaillierungsgrad von Benutzermedien)
• Bezeichnung des Software-Eigentümers (i. Z. mit Mandantenfähigkeit, in Formularköpfen sichtbar)
• Kreditbetrag, Zinssatz, Tilgungsbetrag, Tilgungsperiode (zur Berechnung eines Tilgungsplans)
• Kontonummer als Aufrufparameter an das Unterprogramm 'Prüfziffernberechnung', Prüfziffer als Rückgabewert

In weitestem Sinn sind auch Computerbefehle (in allen Programmiersprachen und auch in Maschinensprache) Parameter: Sie enthalten einen Funktionscode plus Adressen, Längen usw. für die zu verarbeitenden Daten. Die Angaben werden vom Steuerwerk des Computers interpretiert und decodiert und entsprechend ausgeführt.

Ein konkretes Beispiel für die Anwendung von Parametern:

Als Teil einer Anwendung zur Verwaltung von Rechnungen soll ein Programm entstehen, das für die Benutzer Rechnungen in einer Liste ausgibt. Als fachliche Vorgabe wurde festgelegt, dass in dieser Liste alle Rechnungen ausgewiesen werden, die noch nicht bezahlt sind und die älter als 1 Monat sind, berechnet zum Zeitpunkt des Programmlaufs.

• Ohne Parametrisierung würde das Programm also verarbeiten:

Lese Rechnungen; verarbeite nur Rechnungen mit Status = "offen" und Rechnungsdatum < (heute ./. 1 Monat)

• Eine identische Lösung mit Parametern könnte hierzu die Parameter "Rechnungsdatum älter als", "offen_JN" vorsehen.

Hierbei müsste das Programm die Parameter nach dem Start prüfen und ggf. zur Verwendung vorbearbeiten. In der eigentlichen Verarbeitung würden dann keine Konstanten oder fix codierten Befehle (wie vor) verwendet, sondern die gesetzten Parameterwerte.

• Für die Benutzer ergäben sich damit folgende weiter gehenden Möglichkeiten:

Das Alter der Rechnung könnte variabel bestimmt werden; die Liste könnte ggf. auch erledigte Rechnungen oder alle Rechnungen unabhängig vom Status zeigen.

• Weiter gehend könnte z. B. der Parameter "ab Betrag = X" vorgesehen werden oder auch die Festlegung, ob nur Rechnungen mit höheren oder nur Rechnungen mit niedrigeren Rechnungsbeträgen als X oder alle Rechnungen unabhängig von der Betragshöhe aufzulisten sind. Rechnungen mit Bagatellbeträgen könnten so z. B. ausgeschlossen oder in einer getrennten Liste angefordert werden.
• Je nach verwendetem Datenbanksystem können bestimmte Parameter bereits in das Lesekommando für die Rechnungsdaten eingestellt werden, wodurch das DBMS nur entsprechende Rechnungen bereitstellt. Alternativ müsste das Programm die Auswahl nach dem Lesen selbst vornehmen.

Medien zur Parameterübergabe

• Ist das Programm ein Unterprogramm, so werden der (oder auch mehrere Parameter) bei dessen Definition formal festgelegt (formaler Parameter) und (vom Hauptprogramm) beim Aufruf des Unterprogramms für jeweils genau einen Aufruf auf einen konkreten Wert gesetzt (tatsächlicher Parameter).
• Kommandozeilenparameter werden im Aufrufkommando, meist im Anschluss an den Code für die auszuführende Funktion, übergeben. Beispiel: RENAME <alter Dateiname, neuer Dateiname>. In diese Kategorie gehören auch die Parameter, die bei Programmaufrufen über eine Job-Control-Sprache (bei Großrechnerprogrammen z. B. OPC) in den Anweisungen eingestellt werden, z. B. das Tagesdatum.
• Parameter können auch in speziellen Parameterdateien enthalten sein. Ihr Inhalt wird in diesem Fall von einer Steuerungskomponente des Programms zum Ausführungszeitpunkt, ggf. bei Programmstart interpretiert. Beispiele hierfür sind Einträge in sog. Registrierungsdatenbanken (i. d. R. für Dienstprogramme benutzt), aber auch in betrieblichen bzw. aufgabenspezifischen Datenbanken, Dateien oder Tabellenverwaltungssystemen.

Je nach Medium werden Parameter mit unterschiedlichen Verfahren erfasst, externe Parameter häufig mithilfe von Standard- oder individuellen Editoren. Parameter für Dialogprogramme können, wenn dies im Programm vorgesehen ist, vom Benutzer direkt über Bildschirm und Tastatur eingegeben werden.

Definition und technische Anwendung von Parametern

Formale Parameter

Die formalen Parameter eines Unterprogramms werden bei dessen Deklaration oder Definition normalerweise hinter dem Namen des Unterprogramms angegeben. Mit diesen kann im Unterprogramm beispielsweise gerechnet werden, ohne dass konkrete Werte bekannt sind. Bei einer Deklaration sind oft nur die Datentypen der formalen Parameter anzugeben. Die verwendeten Parameter müssen immer zuweisungskompatibel zu diesen formalen Definitionen sein.

Beispiel: Unterprogrammdeklaration in den Programmiersprachen PASCAL und Delphi mit x und y als formalen Parametern:

 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 bei jeder Verwendung zu übergebenden Argumente oder tatsächlichen Parameter.

Tatsächliche Parameter oder Argumente

Zur Verwendung des Unterprogramms wird dieses mit die Ausführung beeinflussenden tatsächlichen Parametern (Argumenten) aufgerufen; diese definieren für diese Ausführung den anfänglichen konkreten Wert der abstrakten formalen Parameter. Zur besseren Unterscheidung von formalen Parametern wurde für tatsächliche Parameter auch die Bezeichnung Argument etabliert, besonders in Beschreibungen von Programmiersprachen.^[1][2] Im Deutschen findet man auch die Bezeichnung aktueller Parameter, durch die falsche Übersetzung des englischen Ausdrucks actual parameter (tatsächlicher Parameter). 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

Kurz: (formale) Parameter stellen benannten Speicherplatz zur Verfügung, ähnlich algebraischen Variablen, Argumente oder tatsächliche Parameter sind konkrete Werte (oder Datenobjekte), die dort gespeichert und entsprechend verwendet werden.

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);

Ersetzen der formalen durch tatsächliche Parameter

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 oder 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 Namen 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 Aufrufparameters 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 wird. 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 Programmen, 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 versierte Benutzer bei Verwendung von Befehlszeilenparametern oft schneller zu Ergebnissen kommen als durch andere Bedienmöglichkeiten, wie beispielsweise 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.

Siehe auch

• Qualitätskriterien für Software nach ISO/IEC 9126
• Ähnliche Bedeutungen von Parameter

Einzelnachweise

1. ↑ British Standards Institute (Hrsg.): The C Standard – Incorporating TC1 – BS ISO/IEC 9899:1999. John Wiley & Sons, 2003, ISBN 0-470-84573-2, 3.1.
2. ↑ Working Draft, Standard for Programming Language C++. Abgerufen am 26. September 2010 (PDF, englisch, Kap. 1.3.1).