Referenzparameter
Referenzparameter (engl. call by reference) sind Parameter von Unterprogrammen in Programmiersprachen, die die Übergabe und Rückgabe von Werten ermöglichen. Ihr Name kommt daher, dass der Compiler in den meisten Programmiersprachen die Adresse des Speicherbereichs einer Variablen oder eines Feldelements übergibt, die als Referenz aufgefasst werden kann.
Normalerweise stehen neben Referenzparametern auch Wertparameter zur Verfügung, die die Übergabe von Ausdrücken erlauben, jedoch keine Rückgabe von Werten.
| Inhaltsverzeichnis |
Beispiel
In der Sprache Pascal muss beim Unterprogrammaufruf für jeden Referenzparameter eine Variable, ein Feld- oder Strukturelement als aktueller Parameter angegeben werden:
1 (* Uebergabe der Variablen X als Referenzparameter in PASCAL *)
2 PROGRAM Demo(input,output);
3 VAR X: integer;
4 PROCEDURE Inkrementiere(VAR N: Integer);
5 BEGIN N:=N+1; END;
6 BEGIN
7 Write('Bitte X eingeben'); ReadLn(X);
8 Inkrementiere(X);
9 Write('Der Nachfolger von X ist: '; WriteLn(X);
10 END.
Die Funktion Inkrementiere hat den Referenzparameter N (Zeile 4), der in Zeile 8 durch die Variable X als aktuellen Parameter X ersetzt wird. Die Unterprogramme Write und WriteLn (Zeilen 7 und 8) verwenden Wertparameter, während ReadLn einen Referenzparameter verlangt (Zeile 7), für den hier auch X eingesetzt wird. Dadurch ist z. B. WriteLn(2*X) ohne weiteres möglich, während ReadLn(2*X) einen Syntaxfehler bei der Übersetzung erzeugt.
Formale und aktuelle Parameter
Im Beispiel wird der Referenzparameter N (Schlüsselwort VAR) verwendet, der bei der Deklaration des Unterprogramms erzeugt wird. Wird VAR weggelassen, so wird ein Wertparameter erzeugt. Beim Aufruf wird der aktuelle Parameter X übergeben.
| Referenzparameter | Wertparameter | |
|---|---|---|
| Formale Parameter | Einfache Variablen und strukturierte Variablen | Einfache Variablen und strukturierte Variablen |
| Aktuelle Parameter | Nur Variablen, Felder, Feldelemente, Strukturelemente. Keine Konstanten und Ausdrücke | Beliebige Ausdrücke wie 1.0, 2*X, sin(x), y[i] |
| Übergabe | Als Adresse übergeben (geringer Aufwand bei Feldern) | Als Kopie (hoher Aufwand bei Feldern) |
| Zuweisung innerhalb Unterprogramm | möglich | möglich oder verboten (je nach Programmiersprache) |
| Rückgabe des Wertes bei Unterprogrammende | ja | nein |
Moderne (optimierende) Compiler können bei Übergabe von Wertparametern ermitteln, ob eine Kopie nötig ist und gegebenenfalls darauf verzichten.
Referenzparameter in Form von Zeigern
Das folgende Beispiel ist in der Sprache C geschrieben. Dabei wird der Referenzparameter in Form einer Zeigers realisiert.
1 /* Uebergabe der Variablen x als Zeigerparameter p in C /*
2
3 #include <stdio.h>
4
5 void increment_p(int* p)
6 {
7 (*p) = (*p) + 1;
8 }
9
11
12 int main()
13 {
14 int x;
15 x = 3;
16
17 increment_p(&x);
18 printf("Das Ergebnis ist %d\n", x);
19 }
In Zeile 17 wird der Adressoperator & verwendet, so dass die Adresse der Variablen x an die Funktion übergeben wird. Diese wird an den Zeigerparameter p (Zeile 5) übergeben.
Referenzparameter in Form von Referenzen
In der Sprache C++ können Referenzparameter ebenso wie in C als Zeiger realisiert werden. In C++ wurde aber auch eine Spracherweiterung eigens zu diesem Zweck eingeführt. Diese Spracherweiterung nennt sich Referenz und hat folgende Notation:
void increment_r(int& r)
{
r = r + 1;
}
Im Vergleich dazu noch einmal das Beispiel für Zeiger:
void increment_p(int* p)
{
(*p) = (*p) + 1;
}
Bei der Variante increment_r entfallen also die Zeigerdereferenzierungen im Funktionsrumpf.
Aufruf der Funktion:
... increment_r(x); ...
Im Unterschied zu der Variante mit increment_p wird also hier beim Aufruf nicht der Adressoperator & verwendet.
Kategorie:Programmierung