Referenzparameter - LinkFang.de





Referenzparameter


Referenzparameter (englisch call by reference oder pass by reference) sind Parameter von Unterprogrammen in Programmiersprachen, mittels derer ein Unterprogramm die übergebenen Argumente wie dessen übergeordnetes Programm verwenden und ändern kann. Jede Veränderung bleibt auch nach Verlassen des Unterprogramms erhalten, da keine Kopien für das Unterprogramm erzeugt werden. Der Nachteil hierbei besteht darin, dass eine ungewollte Beeinflussung von Hauptprogrammvariablen im Unterprogramm möglich ist. Der Name kommt daher, dass der Compiler in den meisten Programmiersprachen die Adresse des Speicherbereichs einer Variablen oder eines Feldelements übergibt (also einen Zeiger auf die Variable oder das Feldelement), die als Referenz (Verweis, Alias) aufgefasst werden kann.

Normalerweise stehen neben Referenzparametern auch Wertparameter zur Verfügung, seltener Wertergebnisparameter.

Beispiel

In der Sprache Pascal muss beim Unterprogrammaufruf für jeden Referenzparameter eine Variable, ein Feld- oder Strukturelement als tatsächlicher Parameter angegeben werden:

  1. (* Uebergabe der Variablen X als Referenzparameter in PASCAL *)
  2. PROGRAM Demo(input,output);
  3.  
  4. PROCEDURE Inkrementiere(VAR N: Integer);
  5. BEGIN
  6.    N:=N+1; 
  7. END;
  8.  
  9. VAR X: integer;
  10. BEGIN 
  11.    Write('Bitte X eingeben'); ReadLn(X);
  12.    Inkrementiere(X);
  13.    Write('Der Nachfolger von X ist: '); WriteLn(X);
  14. END.

Die Funktion Inkrementiere hat den Referenzparameter N (Zeile 4), der in Zeile 13 durch die Variable X als tatsächlicher Parameter X ersetzt wird. Die Unterprogramme Write und WriteLn (Zeilen 11 und 13) verwenden Wertparameter, während ReadLn einen Referenzparameter verlangt (Zeile 11), 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.

Hier ein kleines Beispiel in C++:

  1. #include <iostream>
  2.  
  3. void do_the_square(double& x){
  4.    x = x*x; 
  5. }
  6.  
  7. int main(){
  8.    double value = 2;
  9.    do_the_square(value);
  10.    std::cout << "The square_meters are: " << value << std::endl;
  11. }

Die Funktion do_the_square() arbeitet hier auch mit einer Referenz, und da eine Referenz nur ein Verweis auf eine Variable ist und so kein Wert zurückgegeben werden muss, reicht es, hier im Kopf der Funktion einmal eine Referenz zu setzen.

Beim Aufruf der Funktion muss nur der Wert value (Zeile 8) übergeben werden. Anschließend hat die Funktion den Wert quadriert und value diesen Wert über den Verweis angenommen.

Formale und tatsächliche 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 tatsächliche Parameter N übergeben.

Referenzparameter Wertparameter
formale Parameter einfache Variablen und strukturierte Variablen einfache Variablen und strukturierte Variablen
tatsächliche Parameter nur Variablen, Felder, Feldelemente, Strukturelemente mit genau passendem Datentyp; keine Konstanten und Ausdrücke beliebige Ausdrücke wie 1.0, 2*X, sin(x) oder auch Typumwandlungen
Ü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.

Simulation von Referenzparametern durch Zeiger

Das folgende Beispiel ist in der Sprache C geschrieben, welche keine Referenzparameter kennt. Durch Benutzung von Zeigern kann aber ein ähnliches Verhalten realisiert werden.

  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.  
  10. int main()
  11. {
  12.    int x;
  13.    x = 3;
  14.  
  15.    increment_p(&x); 
  16.    printf("Das Ergebnis ist %d\n", x);
  17. }

In Zeile 15 wird der Adressoperator & verwendet, so dass die Adresse der Variablen x an die Funktion übergeben wird. Diese wird an den Zeigerparameterp (Zeile 5) übergeben.

Referenzparameter in Form von Referenzen

In der Sprache C++ können Referenzparameter ebenso wie in C als Zeiger realisiert werden. Es 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.

Verwendende Programmiersprachen

Siehe auch


Kategorien: Programmierparadigma | Programmiersprachelement

Quelle: Wikipedia - http://de.wikipedia.org/wiki/Referenzparameter (Vollständige Liste der Autoren des Textes [Versionsgeschichte])    Lizenz: CC-by-sa-3.0

Änderungen: Alle Bilder mit den meisten Bildunterschriften wurden entfernt. Ebenso alle zu nicht-existierenden Artikeln/Kategorien gehenden internen Wikipedia-Links (Bsp. Portal-Links, Redlinks, Bearbeiten-Links). Entfernung von Navigationsframes, Geo & Normdaten, Mediadateien, gesprochene Versionen, z.T. ID&Class-Namen, Style von Div-Containern, Metadaten, Vorlagen, wie lesenwerte Artikel. Ansonsten sind keine Inhaltsänderungen vorgenommen worden. Weiterhin kann es durch die maschinelle Bearbeitung des Inhalts zu Fehlern gerade in der Darstellung kommen. Darum würden wir jeden Besucher unserer Seite darum bitten uns diese Fehler über den Support mittels einer Nachricht mit Link zu melden. Vielen Dank!

Stand der Informationen: August 201& - Wichtiger Hinweis: Da die Inhalte maschinell von Wikipedia übernommen wurden, ist eine manuelle Überprüfung nicht möglich. Somit garantiert LinkFang.de nicht die Richtigkeit und Aktualität der übernommenen Inhalte. Sollten die Informationen mittlerweile fehlerhaft sein, bitten wir Sie darum uns per Support oder E-Mail zu kontaktieren. Wir werden uns dann innerhalb von spätestens 10 Tagen um Ihr Anliegen kümmern. Auch ohne Anliegen erfolgt mindestens alle drei Monate ein Update der gesamten Inhalte.