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.

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);
8    Write('Der Nachfolger von X ist: '; WriteLn(X);
9 END.
 

Die Funktion Inkrementiere hat den Referenzparameter N (Zeile 4), der in Zeile 9 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 C

In der Sprache C werden Parameter normalerweise als Wertparameter übergeben. Felder und Unterprogramme werden jedoch immer als Referenzparameter übergeben. Für normale Variablen muss man einen formalen Zeigerparameter erzeugen und über den Adressoperator die Adresse des Variablenspeichers übergeben.

  1 /* Uebergabe der Variablen x als Zeigerparameter p in C /*
  2 int x;
  3 main(argc, argv)
  3    int argc; char ** argv;
  4 {  printf("Bitte Wert eingeben: "); scanf("%d",&x);
  5    increment(&x); 
  6    printf("Das Ergebnis ist %d\n", x);
  7 }
  8 increment(p)
  9     int *p;
 10 {   (*p)=(*p)+1;
 11 }  

In Zeile 5 wird der Adressoperator & verwendet, um die Adresse der Variablen x zu berechnen. Diese wird an den Zeigerparameter p (Zeile 9) übergeben. Auch die scanf-Funktion (Zeile 4) verwendet Zeigerparameter.

Referenzparameter in C++

In der Sprache C++ werden einfache Variablen normalerweise als Wertparameter übergeben. Sie bieteet jedoch eine Syntaxerweiterung, mit der Referenzparameter erklärt werden. Zusätzlich zur C-Übergabe kann man auch folgendermaßen vorgehen:

void foo(int& a)
     {
     ++a;
     }
int main(void)
    {
    int x=0;
    std::cout << x << std::endl;
    foo(x);
    std::cout << x << std::endl;
    return 0;
    }

ergibt als Ausgabe

0
1

Im Vergleich zu C sitzt der Adressoperator im Funktionsrumpf der Funktion void foo(int& a), und es muß kein Zeiger auf einen int verwendet werden (sog. Echte Call-By-Reference).