Parameter
? (deutsch) auch
Ubergabewerte
genannt ? sind in der
Informatik
Variablen
, durch die ein
Computerprogramm
(oft ein
Unterprogramm
) auf die Verarbeitung bestimmter Werte ?eingestellt“ werden kann. Parameter sind also programmextern gesetzte
Einflussfaktoren
; sie werden insbesondere beim Aufruf von Unterprogrammen verwendet, um diesen ?mitzuteilen‘, welche Daten/Werte sie verarbeiten sollen und ggf. wie.
Durch Parametrisierung konnen Programme in ihrer Anwendung flexibilisiert werden, ohne dass das Programm dazu neu erstellt werden muss. Welche Werte eingestellt werden konnen, muss bei der Erstellung von Programmen festgelegt werden. Parameter konnen z. B. bestimmte Grenzwerte/Auswahlbedingungen (fur Betrage, ein Datum oder ahnliches) oder zu verwendende Texte sein oder auch das ?Was“ und das ?Wie“ der Verarbeitung steuern (z. B. Prufung X vornehmen ? ja/nein).
Begrifflich wird unterschieden zwischen ?
formalen Parametern
“ (= als Teil der Funktionsdefinition im Programmcode; Bsp.:
<Funktionsname>( <Par1>, <Par2>, ..)
) und ?
tatsachlichen Parametern
“, auch ?Argumente“ genannt (= der jeweilige Wert fur
Par1
oder
Par2
bei einzelnen Funktionsaufrufen).
Wird beim Aufruf des (Unter-)Programms nicht fur jeden Parameter ein Argument ubergeben, kann dieses eine beim Erstellen des Programms festgelegte
Standardannahme
verwenden oder (je nach Implementierung) die Verarbeitung wegen fehlender Parameter abbrechen.
Prinzip der Parametrisierung
- Parametrisierung ist ein Aspekt der
Softwarearchitektur
: So implementierte
Software
kann den
Qualitatskriterien fur Software nach
ISO/IEC 9126
vor allem in den Punkten
Anpassbarkeit
und
Modifizierbarkeit
entsprechen, unterstutzt aber auch die Anforderungen
Austauschbarkeit
,
Bedienbarkeit
und andere.
- Durch Parametrisierung konnen Programmanderungen fur im Voraus erwartbare Situationen vermieden und damit Aufwand und Fehlerrisiken (durch Programmanderungen) minimiert werden.
- Fur Programmeinsatze in vielen unterschiedlichen Umgebungen (
Mandantenfahigkeit
) ist die Parametrisierung unabdingbare Voraussetzung. Vor allem bei Systemprogrammen wird sie deshalb in der Regel sehr umfassend praktiziert (mindestens uber
Konfigurationsparameter
).
- In der
modularen Programmierung
sind die
Schnittstellen
zwischen den einzelnen Modulen implementierungsimmanente Parameter. Sie sind Bestandteile der
Signatur
von
Funktionen
,
Methoden
und
Prozeduren
und somit ein wesentliches Kommunikationsmedium zwischen aufrufendem Programm und aufgerufenem
Unterprogramm
, Informationen konnen in beide Richtungen fließen.
- Im weiteren Sinn sind auch
Makros
Subroutinen: Fur sie legt der Programmierer im Quelltext Parameter fest und bestimmt damit die Verarbeitungsdetails fur das Makro.
Parameter sind aus Sicht des
Systembegriffs
Inputdaten
; sie unterscheiden sich jedoch von normalen Eingabedaten z. B. wie folgt:
- Parameterdaten gehoren nicht zum eigentlichen Verarbeitungszweck des Programms, sondern sie sollen ? soweit dies bei der Implementierung berucksichtigt wurde ? das Programm auf individuelle Werte / Informationen und / oder mogliche Varianten der Verarbeitung einstellen.
- Parameterdaten sind in der Regel eindimensional, d. h., es gibt keine Objektmengen (wie z. B. in einer Kunden- oder Produktdatei), sondern meist nur die zu einer konkreten Situation gehorenden Angaben, oft nur in Form eines einzelnen
Datenfeldes
.
- Sie werden vom Programm in der Regel nicht einfach gelesen wie andere
Dateien
, sondern haufig uber spezielle Mechanismen (des
Betriebssystems
oder der
Programmiersprache
) interpretiert, insbesondere bei Verwendung als Unterprogramm-Parameter.
- Außer bei Unterprogrammen werden sie meist durch die fur den technischen Ablauf des Programms verantwortlichen
Benutzer
,
Nutzer
oder Betreiber von Computern vorgegeben, z. B. Mitarbeiter des Rechenzentrums, und bleiben in diesen Fallen oft uber langere Zeit unverandert.
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 konnen.
- als Schnittstelle zwischen aufrufenden Programmen und aufgerufenen Unterprogrammen; siehe unten.
Bei Verwendung mehrerer Parameter ist es wichtig, die einzelnen Parameter identifizieren und unterscheiden zu konnen. Hierzu gibt es zwei Erkennungsmethoden:
- Positionsparameter
- werden bei der Ubergabe anhand ihrer Position zugewiesen. Beispiel: Der dritte Parameter ist die Startzeit. Wenn die Parameterwerte keine feste Lange haben, mussen Positionsparameter durch ein
Trennzeichen
getrennt werden. Als Trennzeichen wird z. B. das
Semikolon
(siehe
CSV-Datei
) oder der
senkrechte Strich
verwendet. Nicht vorzugebende Argumente werden hierbei in der Regel nur durch ihr Trennzeichen gekennzeichnet, was zu Stringfolgen wie
300;ABC;;;XYZ
(dritter und vierter Parameter nicht verwendet) fuhrt.
- Schlusselwortparameter
- werden bei der Ubergabe mit einem eindeutigen
Schlusselwort
gekennzeichnet und sind somit unabhangig von ihrer Position identifizierbar. Beispiel:
startzeit=13:30
. Auch bei Schlusselwortparametern ist ein Trennzeichen erforderlich.
- Schlusselwortparameter zeichnen sich gegenuber Positionsparametern meist dadurch aus, dass sie auch weggelassen werden konnen.
Ob leere Parameter erlaubt sind und wie dies zu behandeln ist, z. B. leere Zeichenkette oder
Standardannahme
(englisch
default argument
), ist durch das Programm zu behandeln. Ebenso muss fur beide Varianten festgelegt/vereinbart sein, in welchem
Format
sie anzugeben sind; im Beispiel: ?hh:mm“, jeweils 2 Stellen, getrennt durch einen Doppelpunkt.
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
- Stabilitat / Anderungshaufigkeit
- Wird der Parameter haufig oder
fast immer neu
gesetzt oder wird er
selten verandert
?
- Art / Typ der Parameter
- Variablen
wie Betragsfelder (z. B. Grenzwerte), Zeitangaben (Tagesdatum), Textkonstanten und so weiter oder
funktional wirkende Anweisungen
wie ?J/N“ o. a. (fur ?nur fehlerhafte Daten auflisten‘, ?nur protokollieren, nicht speichern‘)
- Richtung des Informationsflusses
- Aufrufparameter
(in Richtung Programm / Unterprogramm) oder
Ruckgabeparameter
(in Richtung aufrufendes Programm; nur bei Unterprogrammen); auch
bidirektional
ist moglich (Aufruf / Ruckgabe)
- Mehrwertsteuersatze in Prozent (bei betriebswirtschaftlichen Anwendungen)
- Sollen in Listen nur Summen- oder auch Einzelzeilen ausgegeben werden? (steuert den Detaillierungsgrad von Benutzermedien)
- Bezeichnung des Software-Eigentumers (i. Z. mit
Mandantenfahigkeit
, in Formularkopfen sichtbar)
- Kreditbetrag, Zinssatz, Tilgungsbetrag, Tilgungsperiode (zur Berechnung eines
Tilgungsplans
)
- Kontonummer
als Aufrufparameter an das Unterprogramm 'Prufziffernberechnung’,
Prufziffer
als Ruckgabewert
In weitestem Sinn sind auch Computerbefehle (in allen
Programmiersprachen
und auch in
Maschinensprache
) Parameter: Sie enthalten einen Funktionscode plus Adressen, Langen und so weiter fur die zu verarbeitenden Daten. Die Angaben werden vom
Steuerwerk
des Computers interpretiert und decodiert und entsprechend ausgefuhrt.
Ein konkretes Beispiel fur die Anwendung von Parametern:
Als Teil einer Anwendung zur Verwaltung von Rechnungen soll ein Programm entstehen, das fur 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 alter als 1 Monat sind, berechnet zum Zeitpunkt des Programmlaufs.
- Ohne Parametrisierung wurde das Programm also verarbeiten:
- Lese Rechnungen; verarbeite nur Rechnungen mit Status = ?offen“ und Rechnungsdatum < (heute ./. 1 Monat)
- Eine identische Losung mit Parametern konnte hierzu die Parameter ?Rechnungsdatum alter als“, ?offen_JN“ vorsehen.
- Hierbei musste das Programm die Parameter nach dem Start prufen und gegebenenfalls zur Verwendung vorbearbeiten. In der eigentlichen Verarbeitung wurden dann keine Konstanten oder fix codierten Befehle (wie vor) verwendet, sondern die gesetzten Parameterwerte.
- Fur die Benutzer ergaben sich damit folgende weiter gehenden Moglichkeiten:
- Das Alter der Rechnung konnte variabel bestimmt werden; die Liste konnte gegebenenfalls auch erledigte Rechnungen oder alle Rechnungen unabhangig vom Status zeigen.
- Weiter gehend konnte z. B. der Parameter ?ab Betrag = X“ vorgesehen werden oder auch die Festlegung, ob nur Rechnungen mit hoheren oder nur Rechnungen mit niedrigeren Rechnungsbetragen als X oder alle Rechnungen unabhangig von der Betragshohe aufzulisten sind. Rechnungen mit Bagatellbetragen konnten so z. B. ausgeschlossen oder in einer getrennten Liste angefordert werden.
- Je nach verwendetem Datenbanksystem konnen bestimmte Parameter bereits in das Lesekommando fur die Rechnungsdaten eingestellt werden, wodurch das
DBMS
nur entsprechende Rechnungen bereitstellt. Alternativ musste das Programm die Auswahl nach dem Lesen selbst vornehmen.
- 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 fur jeweils genau einen Aufruf auf einen konkreten Wert gesetzt (tatsachlicher Parameter).
- Kommandozeilenparameter
werden im Aufrufkommando, meist im Anschluss an den Code fur die auszufuhrende Funktion, ubergeben. Beispiel: RENAME <alter Dateiname, neuer Dateiname>. In diese Kategorie gehoren auch die Parameter, die bei Programmaufrufen uber eine
Job-Control-Sprache
(bei
Großrechnerprogrammen
z. B.
OPC
) in den Anweisungen eingestellt werden, z. B. das Tagesdatum.
- Parameter konnen auch in speziellen
Parameterdateien
enthalten sein. Ihr Inhalt wird in diesem Fall von einer Steuerungskomponente des Programms zum Ausfuhrungszeitpunkt, gegebenenfalls bei Programmstart interpretiert. Beispiele hierfur sind Eintrage in sog.
Registrierungsdatenbanken
(in der Regel fur
Dienstprogramme
benutzt), aber auch in betrieblichen bzw. aufgabenspezifischen
Datenbanken
,
Dateien
oder Tabellenverwaltungssystemen.
Je nach Medium werden Parameter mit unterschiedlichen Verfahren
erfasst
, externe Parameter haufig mithilfe von Standard- oder individuellen
Editoren
. Parameter fur
Dialogprogramme
konnen, wenn dies im Programm vorgesehen ist, vom Benutzer direkt uber
Bildschirm
und
Tastatur
eingegeben werden.
Eine essentielle Bedeutung haben Parameter in Verbindung mit der Verwendung von Unterprogrammen. Diese verarbeiten Daten und liefern Werte zuruck, die meist zu den sie aufrufenden Programmen gehoren. Um einem Unterprogramm (das die Daten des rufenden Programms grundsatzlich nicht 'kennt') die Teilmenge an Daten mitzuteilen, die es verarbeiten muss, verwendet man beim Aufruf des Unterprogramms bestimmte Techniken, die in hoheren Programmiersprachen durch eine sogenannte
formale Parameterliste
abgebildet werden. Dieser Ausdruck wurde bereits in den 1960er Jahren fur die damals als Lehrbeispiel entstandene Sprache
ALGOL
benutzt und ist noch heute ublich. Die Begriffe
Parameter
oder
Argument
werden in diesem Kontext oft synonym verwendet, wobei sich ?Parameter“ genau genommen auf die Funktionsdefinition bezieht, ?Argument“ hingegen auf den tatsachlichen Aufruf. Den Unterprogrammen wird beim Aufruf uber die
tatsachliche Parameterliste
(genauer: Argumentliste) bestimmte Werte ubergeben, mit denen sie arbeiten konnen. Die Unterprogramme liefern in der Regel
Ruckgabewerte
zuruck.
Alle genannten
Werte
konnen auch
Referenzen
,
Zeiger
oder
Adressen
auf Speicherbereiche sein. Die genannten Begriffe sind ebenfalls synonym. Im C++-Jargon wird allerdings oft streng zwischen
Referenz
und
Zeiger
unterschieden, mit
Referenz
wird die mit
Type&
deklarierte Variante bezeichnet, Zeiger dagegen mit
Type*
. Der Unterschied besteht darin, das eine Referenz im Gegensatz zum Zeiger nicht uninitialisiert oder leer sein darf. Das bedeutet, bei Verwendung einer Referenz muss immer ein gultiges Objekt des entsprechenden Typs ubergeben werden. Referenzen auf Grunddatentypen sind ebenfalls erlaubt (z. B.
int&
).
Abhangig von der Rechnerarchitektur und der Programmiersprache werden zur Ubergabe von Parametern vom aufrufenden an den aufzurufenden Softwareteil unterschiedliche Verfahren und Konventionen benutzt. Zum Beispiel konnen die Parameter uber
Register
ubergeben werden, wobei durch Konventionen festgelegte Register(nummern) auf eine Adressliste zeigen (die die Adressen der Parameter/Argumente enthalt), ein Register enthalt die Einsprungadresse im Unterprogramm, ein anderes die Rucksprungadresse. Details siehe
Objektmodule bei Großrechnern
.
In anderen
Systemumgebungen
wird dazu einen
Stack
-Mechanismus verwendet. In diesen Fallen ist zum Verstandnis der Funktionsweise von Unterprogrammen folgendes Basiswissen notwendig:
Grundsatzlich ist der Speicher von Prozessoren unterteilt in
- Programmspeicher: Dort steht der Maschinencode, der als Befehle abgearbeitet wird.
- Dynamischer Speicher
(
Heap
): Dort sind Daten abgespeichert.
- Stapelspeicher
(
Stack
,
Aufrufstapel
): Das ist ein besonderer Datenbereich, dessen Verwendung insbesondere bei Unterprogrammen eine Rolle spielt.
Jeder
Thread
hat seinen eigenen Stapelspeicher. In diesem werden gespeichert:
- Die Rucksprungadressen fur die Fortsetzung der Programmbearbeitung nach Abarbeitung des Unterprogramms
- Die tatsachlichen Parameter
- Alle Daten, die lokal in einer Prozedur vereinbart werden
- Ruckgabewerte
Der Stack wird bei der Programmabarbeitung im Maschinencode uber ein spezielles Adressregister adressiert, den
Stackpointer
oder
Stapelzeiger
. Dieser adressiert immer das untere Ende des als Stack benutzen Speicherbereiches. Hinzu kommt zumeist ein
Basepointer
, der eine Basisadresse der Variablen und tatsachlichen Parameter innerhalb des Stacks adressiert. Der Begriff
Stack
ist im Deutschen als ?Stapel“ ubersetzbar, auch der Begriff ?Kellerspeicher“ wird benutzt. Im Stack werden Informationen gestapelt und nach dem Prinzip
Last In ? First Out
(LIFO) gespeichert und wieder ausgelesen. Allerdings kann der Zugriff auch auf beliebige Adressen innerhalb des Stacks erfolgen.
Die Parameterubergabe erfolgt uber den Stack. Jeder tatsachliche Parameter wird in der Reihenfolge der Abarbeitung, ublicherweise von links nach rechts (gemaß einer strikt festgelegten
Aufrufkonvention
), auf den Stack gelegt. Dabei erfolgt, falls notwendig, eine
Konvertierung
auf das Format, das vom Unterprogramm benotigt wird.
Bei Aufruf des Unterprogramms wird dann der sogenannte
Basepointer
auf die nunmehr erreichte Adresse des Stacks gesetzt. Damit sind die Parameter des Unterprogramms relativ uber die Adresse, die im
Basepointer
gespeichert ist, erreichbar, auch wenn der Stack fur weitere Speicherungen benutzt wird.
Werden in der tatsachlichen Parameterliste nicht nur
elementare Datentypen
wie
int
oder
float
angegeben, sondern komplette
Datenstrukturen
, dann werden im Stack meist nicht die Werte der Datenstruktur selbst, sondern Referenzen (Adressen) auf die Datenstrukturen ubergeben. Das hangt allerdings vom Aufruf und der Gestaltung der tatsachlichen Parameterliste ab. In C und C++ ergeben sich folgende Verhaltnisse:
void
function
(
type
*
data
)
// Funktionskopf, formale Parameterliste
…
struct
{
int
a
,
float
b
}
data
;
// Datendefinition
function
(
&
data
);
// Funktionsaufruf, tatsachliche Parameterliste
In diesem Fall erfolgt beim Aufruf die explizite Angabe der Adresse der Daten, ausgedruckt mit dem
&
als Referenzierungsoperator. Beim Aufruf ist
data
ein Zeiger (englisch
pointer
) auf die Daten. Allgemein ausgedruckt kann von
Referenz auf die Daten
gesprochen werden.
Der Aufruf
function(data)
ohne den Referenzierungsoperator
&
fuhrt zu einem Syntaxfehler. In C allerdings nur, wenn der
Prototyp
der gerufenen Funktion bekannt ist.
In C++ kann der
Funktionskopf
im gleichen Beispiel mit
void function(type& data)
geschrieben werden. Dann ist der Aufruf mit
function(data)
zu gestalten. Der Ubersetzer erkennt automatisch aufgrund des in C++ notwendigerweise bekannten Funktionsprototyps, dass die Funktion laut formaler Parameterliste eine Referenz erwartet und kompiliert im Maschinencode das Ablegen der Adresse der Daten auf den Stack. Das entlastet den Programmierer von Denkarbeit, der Aufruf ist einfacher. Allerdings ist beim Aufruf nicht ersichtlich, ob die Daten selbst (
call by value
) oder die Adresse der Daten ubergeben wird.
In C oder C++ ist es auch moglich, anstelle der meist sinnvollen und gebrauchlichen Referenzubergabe eine Wertubergabe zu programmieren. Das sieht wie folgt aus:
void
function
(
type
data
)
// Funktionskopf, formale Parameterliste
…
struct
{
int
a
,
float
b
}
data
;
// Datendefinition
function
(
data
);
// Funktionsaufruf, tatsachliche Parameterliste
Beim Aufruf wird der Inhalt der Struktur insgesamt auf den Stack kopiert. Das kann sehr viel sein, wenn die Struktur umfangreich ist. Dadurch kann es zum Absturz des gesamten Ablaufes kommen, wenn die Stackgrenzen uberschritten werden und dies in der Laufzeitumgebung nicht erkannt wird. Eine Wertubergabe ist allerdings sinnvoll in folgenden Fallen:
- Ubergabe einer kleinen Struktur
- Einkalkulierung der Tatsache, dass der Inhalt der originalen Struktur wahrend der Abarbeitung verandert wird. Die Inhalte der Struktur beim Aufrufer bleiben unverandert, da eine Kopie der Daten angelegt und ubergeben wird.
In vielen Programmiersprachen ist ein Ruckschreiben von Ergebnissen auch uber Referenzen, die als Parameter des Unterprogramms ubergeben wurden, moglich, beispielsweise in C und C++:
void
function
(
Type
*
data
)
{
data
->
a
=
data
->
b
*
2
;
// Wert in data->a wird veraendert.
}
Das gilt gleichermaßen fur Java. Das Ruckschreiben kann ungewollt sein, weil Nebenwirkungen (Nebeneffekte) verhindert werden sollen. Ein Unterprogramm soll die Werte von bestimmten Datenstrukturen nur lesend verarbeiten und wirkungsfrei darauf sein. In C++ (bzw. in C) ist es moglich, zu formulieren:
void
function
(
Type
const
*
data
)
{
data
->
a
=
data
->
b
*
2
;
// Hier meldet der Ubersetzer einen Syntaxfehler.
}
Die hier verwendete Schreibweise mit dem Schlusselwort
const
soll deutlich machen, dass der gezeigerte (referenzierte) Bereich als konstant zu betrachten ist. Moglicherweise wird
const Type*
geschrieben, was syntaktisch und semantisch identisch ist. Nur in diesem Fall ist es moglich, einen als konstant deklarierten Speicherbereich uberhaupt zu ubergeben. Die Konstruktion
const
struct
Type
{
int
a
,
float
b
}
data
=
{
5
,
27.2
};
function
(
Type
*
data
)
{
…
}
// Funktionsdefinition
function
(
&
data
);
// Aufruf
fuhrt in C++ zu einem Syntaxfehler, weil es nicht gestattet ist, als konstant bezeichnete Daten an eine nicht konstante Referenz zu ubergeben. In C werden Zeigertypen nicht so genau getestet, so dass dieses Beispiel ? abhangig vom verwendeten Ubersetzer ? in solchen Fallen moglicherweise lediglich eine Warnung auslosen wurde.
Allerdings ist es in C und C++ moglich, innerhalb der Funktion den Typ des Zeigers zu wandeln und dann dennoch schreibend auf den Speicherbereich zuzugreifen. Eine solche Programmierung sollte nur in Sonderfallen verwendet werden und sollte nach außen entsprechend dokumentiert werden.
In Java gibt es die Moglichkeit der
const
-Auszeichnung in einem Referenzparameter zur Unterscheidung des schreibenden oder nicht schreibenden Zugriff auf eine Instanz nicht. Das Konzept sieht stattdessen vor, den Zugriffsschutz uber
private
-Kapselung zu realisieren. Insbesondere konnen spezifische
interface
-Referenzen verwendet werden. Mit dieser Methodik ist es moglich, von außen zu kontrollieren, was eine Subroutine an den ubergebenen Daten andern kann, ohne die Subroutine im Detail zu kennen.
In der
objektorientierten Programmierung
in Java und C++ wird die Referenz auf die Klassendaten implizit mit dem
this
-Zeiger ubergeben. Fur Klassenmethoden ist also das Schreiben auf die eigenen Daten immer moglich.
Das Konzept des Stack wurde weiter oben im Abschnitt
Ubergabe uber den Stack
bereits erlautert.
Fur Unterprogramme auf Maschinensprachniveau (Assembler) ist es an sich gleichgultig, beziehungsweise liegt es in der Hand des Programmierers, wie er die Parameterubergabe und die Rucksprungadresse verwaltet. Moglich ist auch die Ubergabe und Speicherung ausschließlich in Prozessorregistern. Allerdings ist bei der Verwaltung der Rucksprungadresse die Notwendigkeit eines geschachtelten Aufrufs mehrerer (typisch verschiedener) Unterprogramme ineinander zu beachten. Nur bei ganz einfachen Aufgaben ist eine Beschrankung auf wenige oder nur eine Ebene sinnvoll. Es gibt aber tatsachlich bei zugeschnittenen Prozessoren und Aufgabenstellungen auch solche Konzepte.
- Die Rucksprungadresse, das ist die Folgeadresse nach dem Aufruf der Unterprogramme fur die Fortsetzung des aufrufenden Programmes, wird auf den Stack gelegt.
- Zuvor werden die Aufrufparameter auf den Stack gelegt.
- Noch zuvor wird ein gegebenenfalls notwendiger Speicherplatz fur Ruckgabewerte auf dem Stack reserviert, wenn notwendig.
- Der Basepointer wird auf den Stack gelegt.
- Danach wird das Unterprogramm aufgerufen, das heißt, der
Befehlszahler
wird geandert auf die Startadresse des Unterprogramms.
- Am Beginn des Unterprogramms wird der Basepointer auf den Wert des Stackpointers gesetzt als Adressbezug der Lage der Parameter, des Rucksprunges und der lokalen Variablen.
- Der Stackpointer wird gegebenenfalls weiter dekrementiert, wenn das Unterprogramm lokale Variablen benotigt. Diese liegen auf dem Stack.
- Am Ende des Unterprogramms wird der ursprungliche Wert des Basepointer vom Stack geholt und damit restauriert.
- Dann wird die Rucksprungadresse vom Stack geholt und der Instruction Pointer damit restauriert.
- Der Stackpointer wird inkrementiert um den Wert, um den vorher dekrementiert wurde.
- Damit wird das aufrufende Programm fortgesetzt.
In Assembler muss man all diese Dinge selbst programmieren. In den Programmiersprachen C++ und C ubernimmt das der Ubersetzer. In Java erfolgt innerhalb der Speicherbereiche der Virtuellen Maschine das Gleiche, organisiert vom
Bytecode
(erzeugt vom Java-Ubersetzer) und dem Maschinencode in der virtuellen Maschine.
Als Illustration sei hier der erzeugte Assembler-Code (
80x86
-Assembler) der folgenden einfachen Funktion gezeigt:
float
parabel
(
float
x
)
{
return
x
*
x
;
}
Als Compiler wurde
Microsoft Visual Studio
6 auf einem PC verwendet. Der Assemblercode ist in dieser
IDE
sichtbar, beispielsweise beim Debuggen in Maschinenebene, aber auch wenn mit entsprechenden Compileroptionen Listingfiles erzeugt werden.
Maschinencode fur den Aufruf:
float y = parabel(2.0F);
push
40000000
h
; Der Wert 2.0 wird in den Stack gelegt.
call
parabel
; Aufruf des Unterprogramms;
; call legt den Instructionpointer in den Stack
add
esp
,
4
; Addieren von 4, das ist Byteanzahl des Parameters
fst
dword
ptr
[
ebp
-
4
]
; Abspeichern des Ergebnisses in y
Maschinencode des Unterprogramms:
parabel:
push
ebp
; Der Basepointer wird im Stack gespeichert.
mov
ebp
,
esp
; Der Basepointer wird mit dem Wert des Stackpointer geladen.
sub
esp
,
40
h
; 64 Byte Stack werden reserviert.
push
ebx
; CPU-Register, die hier verwendet = geandert werden,
push
esi
; werden im Stack zwischengespeichert.
push
edi
fld
dword
ptr
[
ebp
+
8
]
; Der Wert des Parameters x wird relativ zum Basepointer geladen
fmul
dword
ptr
[
ebp
+
8
]
; und in der floating-point-unit mit selbigem multipliziert.
pop
edi
; Register werden restauriert.
pop
esi
pop
ebx
mov
esp
,
ebp
; Der Stackpointer wird genau auf den Stand wie beim Aufruf
; des Unterprogramms gebracht.
pop
ebp
; Der Basepointer wird aus dem Stack restauriert.
ret
; Der Instruction pointer wird aus dem Stack restauriert
; und damit wird nach dem call (oben) fortgesetzt.
Folgendes Beispiel zeigt einen handgeschriebenen Assemblercode fur den Signalprozessor ADSP-216x von Analog Devices fur folgende aus C zu rufende Funktion:
float
set_floatExtend
(
_floatExtend
*
dst
,
float
nVal
);
Dabei handelt es sich um eine Funktion, die einen in
nVal
stehenden Wert auf der Adresse
dst
speichern soll. Das Besondere hierbei ist, dass der Fließkommawert 40 Bit umfasst und auf zwei 32-bittige Speicheradressen aufgeteilt werden muss.
.GLOBAL
_set_floatExtend
; ; Sprunglabel global sichtbar
_set_floatExtend:
; Sprunglabel angeben, das ist der Name des Unterprogramms,
; aus C ohne Unterstrich anzugeben.
I4
=
R4
; ; Im Register R4 wird der erste Parameter _floatExtend* dst ubergeben.
; Da es eine Adresse ist, wird diese in das Adressregister I4 umgeladen.
PX
=
F8
; ; Der zweite Parameter float nVal wird aus F8 in das Register PX geladen.
dm
(
0
,
I4
)
=
PX1
; ; Ein Teil des Inhaltes von PX, in PX1 sichtbar, wird auf
; der Adresse gespeichert, die von I4 gezeigert wird.
dm
(
1
,
I4
)
=
PX2
; ; Speicherung des zweiten Teils auf der Folgeadresse
!
FUNCTION
EPILOGUE
:
; Standard-Abschluss des Unterprogramms:
i12
=
dm
(-
1
,
i6
)
; ; Das Adressregister i12 wird aus einer Adresse relativ zum Basepointer
; (hier i6) geladen. Das ist die Rucksprungadresse.
jump
(
m14
,
i12
)
(
DB
)
; Das ist der Rucksprung unter Nutzung des Registers i12.
F0
=
F8
; ; nach dem Rucksprung werden die noch im cashe stehenden Befehl verarbeitet,
; hier wird der Wert in F8 nach dem Register R0 geladen, fur return.
RFRAME
; ; dieser Befehl korrigiert den Basepointer i6 und Stackpointer i7.
Definition und technische Anwendung von Unterprogramm-Parametern
[
Bearbeiten
|
Quelltext bearbeiten
]
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 mussen 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 fur die bei jeder Verwendung zu ubergebenden Argumente oder tatsachlichen Parameter.
Zur Verwendung des Unterprogramms wird dieses mit die Ausfuhrung beeinflussenden tatsachlichen Parametern (Argumenten) aufgerufen; diese definieren fur diese Ausfuhrung den anfanglichen konkreten Wert der abstrakten formalen Parameter. Zur besseren Unterscheidung von formalen Parametern wurde fur tatsachliche 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 Ubersetzung des englischen Ausdrucks
actual parameter
(tatsachlicher Parameter). Die Art der Ubergabe ist von Programmiersprache zu Programmiersprache verschieden. Die Sprache
Fortran
verwendet beim Ubersetzen festgelegte Speicheradressen fur jedes Unterprogramm. Sprachen wie
Pascal
oder
C
verwenden den
Stack
oder Prozessorregister zur Parameterubergabe.
Beispiel: Aufruf des Unterprogramms mit verschiedenen tatsachlichen Parametern:
r1
:=
Radius
(
x1
,
y1
)
;
--
tats
a
chliche
Parameter
x
:=
x1
und
y
:=
y1
Durchmesser
:=
2
*
Radius
(
13
,
-
2
)
;
--
tats
a
chliche
Parameter
x
:=
13
und
y
:=
-
2
Kurz: (formale) Parameter stellen benannten Speicherplatz zur Verfugung, ahnlich algebraischen Variablen, Argumente oder tatsachliche Parameter sind konkrete Werte (oder Datenobjekte), die dort gespeichert und entsprechend verwendet werden.
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 fuhrt zu einem
Syntaxfehler
), wahrend
Skriptsprachen
haufig keine Moglichkeit bieten Type-Hinting zu verwenden.
- Ein Beispiel aus
C
bzw.
C++
:
float
radius
(
float
x
,
float
y
);
- Ein Beispiel aus
PHP
ohne Type-Hinting:
function
radius
(
$x
,
$y
);
- Ein Beispiel aus
PHP
mit Type-Hinting:
/* Der erste Parameter muss vom Typ der Klasse PDO sein, andernfalls wird ein Fehler erzeugt */
function
getData
(
PDO
$db
,
$y
);
Es gibt unterschiedliche Methoden, wie die formalen Parameter wahrend der Parameterubergabe durch die tatsachlichen Parameter ersetzt werden:
- 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 tatsachlichen Parameter konnen beliebige Ausdrucke wie
oder
sein. Etwaige Anderungen der Parameter im Unterprogramm werden nur in der
Kopie
durchgefuhrt und gehen bei Abschluss des Unterprogramms verloren. Große Datenstrukturen wie Felder werden bei der Ubergabe kopiert, was unerwunscht sein kann.
- Referenzparameter
(
call by reference
) ubergeben eine Referenz (normalerweise die Speicheradresse) des tatsachlichen Parameters. Dies ist in der Regel sehr schnell. Anderungen bleiben auch nach Abschluss des Unterprogramms wirksam. Tatsachliche Parameter konnen nur Ausdrucke sein, deren Adresse berechnet werden kann, also z. B. keine Konstanten.
- Namensparameter
(
call by name
) setzen den Namen des tatsachlichen Parameters an Stelle des formalen Parameters ein. Dies kann auch mehrfach geschehen. Zusammen mit dem tatsachlichen Parameter wird eine Umgebung ubergeben, welche die Bindungen der freien Variablen, welche im tatsachlichen 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 tatsachlichen Parameter ersetzt. Der Unterschied zu
Namensparametern
besteht darin, dass Namenskonflikte in Kauf genommen werden. Kommt in einem tatsachlichen Parameter eine Variable vor, welche den gleichen Namen wie eine lokale Variable besitzt, so wird bei der Makroexpansion die lokale Variable verwendet.
- Wertergebnisparameter
(
call by value/return
oder
call by value and result
) erzeugen wie Wertparameter beim Aufruf zunachst eine Kopie des tatsachlichen Parameters. Bei Unterprogrammende wird der Inhalt des Parameters jedoch zuruckgeschrieben. Dieser Parameterubergabemechanismus kann bei nebenlaufigen Programmen eine andere Wirkung als die Verwendung von Referenzparametern haben, da wahrend der Ausfuhrungszeit des Unterprogramms ein anderer Thread auf die Variable in der aufrufenden Prozedur zugreifen kann.
- Ergebnisparameter
(
call by result
) erstellen eine lokal gultige, nicht initialisierte Variable als Parameter. Dieser Variable wird wahrend der Abarbeitung des Unterprogramms ein Wert zugewiesen und bei Unterprogrammende in die Speicherposition des Aufrufparameters kopiert, sodass dieser uberschrieben wird.
- Call-by-Need ist eine Variante von
Namensparametern
, bei der jeder ubergebene tatsachliche Parameter maximal einmal ausgewertet wird. Wird ein tatsachlicher 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 unterstutzen in der Regel Wertparameter und Referenzparameter, manchmal auch Wertergebnisparameter.
proc
test
(
x
,
y
)
{
y
=
y
+
1
;
x
=
10
*
x
;
}
a
=
5
;
b
=
4
;
test
(
a
,
b
);
print
(
a
,
b
);
test
(
b
,
b
);
print
(
b
);
- Ausgabe bei Wertparametern (
call by value
)
Erklarung: Es wird durch die Aufrufe von
test
keine Veranderung an den Variablen a und b durchgefuhrt, sodass die Variablen jeweils nach Beendung des Unterprogramms ihren ursprunglichen Wert beibehalten.
- Ausgabe bei Referenzparametern (
call by reference
)
Erklarung: Beim Aufruf von
test
in Zeile 9 erhalt x die Referenz zu a und y die Referenz zu b. Bei der Abarbeitung wird y zunachst um 1 erhoht. Da b und y auf die gleiche Adresse verweisen, hat b also nun den Wert 5. In der nachsten Zeile wird x mit 10 multipliziert, somit hat a nun den Wert 50.
In der zweiten Abarbeitung von
test
, aufgerufen in Zeile 11, verweisen sowohl x, als auch y auf b, da b fur beide Parameter angegeben wurde. Daher werden alle Veranderungen, die in
test
an x und y ausgefuhrt werden, im gleichen Speicherbereich ausgefuhrt. y hatte vor diesem Aufruf den Wert 5, wird in Zeile 3 um 1 erhoht und anschließend wird in Zeile 4 dieser Wert mit 10 multipliziert; also steht an der Speicherstelle nun der Wert 60. Zuruck im Hauptprogramm weist b dann auf die Adresse, an der die soeben berechnete 60 steht, also wird 60 in Zeile 12 fur b ausgegeben.
- Ausgabe bei Wertergebnisparametern (
call by value and result
)
Erklarung: Beim zweiten Aufruf von
test
werden zwei Kopien von b erstellt, auf die x und y innerhalb von
test
zeigen. x hat bei Beendung des Unterprogramms den Wert 50, y hat den Wert 6. Je nach dem, welcher Wert zuerst in das ursprungliche b zuruck gespeichert wird, kann das Ergebnis variieren.
Zudem besteht bei vielen gangigen
Programmen
fur alle gangigen
Betriebssysteme
die Moglichkeit, Parameter in der
Befehlszeile
zu ubergeben, die dann beim Aufrufen bearbeitet werden.
Beispiel: Fiktiver Programmaufruf uber die Befehlszeile unter
Windows
programm.exe
-parameter
-weiterer
-xyz
=(
a
|
b
)
/usw
Hiermit wurde 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 angehangt wird. Je nachdem, welches Programm verwendet wird, stehen verschiedene Parameter zur Verfugung; je nach Programm haben gleich benannte Parameter im Allgemeinen unterschiedliche Auswirkungen. Auch die formalen Regeln zur Angabe sind vom Programm abhangig; dass, wie im Beispiel, mehrere unterschiedliche Trennzeichen verwendet werden, ist zwar unublich und dient nur der Demonstration, aber viele Programme bieten durchaus flexible Moglichkeiten.
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 fur das jeweilige Programm feststehenden Menge ausgewahlt werden konnen; dagegen werden Parameter nicht besonders eingeleitet, wenn es sich um Dateinamen und ahnliche 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 Bedienmoglichkeiten, 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.
- ↑
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.
- ↑
Working Draft, Standard for Programming Language C++.
(PDF; 4,6 MB)
Abgerufen am 26. September 2010
(englisch, Kap. 1.3.1).