imported>Diaspomod: /* Beispiel */

2019-09-13T21:29:13Z

Beispiel

Neue Seite

'''Referenzparameter''' ({{enS}} ''call by reference'' oder ''pass by reference'') sind [[Parameter (Informatik)|Parameter]] von Unterprogrammen in [[Programmiersprache]]n, 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 (Informatik)|Zeiger]] auf die Variable oder das Feldelement), die als [[Referenz (Programmierung)|Referenz]] (Verweis, Alias) aufgefasst werden kann.

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

== Beispiel ==

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

<syntaxhighlight highlight="4,13" lang="pascal">
// Uebergabe der Variablen X als Referenzparameter in PASCAL
program Demo(input, output);

procedure Inkrementiere(var n: Integer);
begin
n := n + 1;
end;

var X: integer;
begin
Write('Bitte X eingeben');
ReadLn(X);
Inkrementiere(X);
Write('Der Nachfolger von X ist: ');
WriteLn(X);
end.
</syntaxhighlight>

Die Funktion <code>Inkrementiere</code> hat den Referenzparameter <code>N</code> (Zeile 4), der in Zeile 13 durch die Variable <code>X</code> als tatsächlicher Parameter <code>X</code> ersetzt wird. Die Unterprogramme <code>Write</code> und <code>WriteLn</code> (Zeilen 11 und 13) verwenden [[Wertparameter]], während <code>ReadLn</code> einen Referenzparameter verlangt (Zeile 11), für den hier auch <code>X</code> eingesetzt wird. Dadurch ist z. B. <code>WriteLn(2*X)</code> ohne Weiteres möglich, während <code>ReadLn(2*X)</code> einen Syntaxfehler bei der Übersetzung erzeugt.

Hier ein kleines Beispiel in C++:

<syntaxhighlight highlight="8" lang="cpp">
#include <iostream>

void do_the_square(double& x) {
x = x * x;
}

int main() {
double value = 2;
do_the_square(value);

std::cout << "The square_meters are: " << value << std::endl;

return 0;
}
</syntaxhighlight>

Die Funktion <code>do_the_square()</code> 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 <code>value</code> (Zeile 8) übergeben werden.
Anschließend hat die Funktion den Wert quadriert und <code>value</code> diesen Wert über den Verweis angenommen.

== Formale und tatsächliche Parameter ==

Im Beispiel wird der Referenzparameter <code>N</code> (Schlüsselwort <code>VAR</code>) verwendet, der bei der Deklaration des Unterprogramms erzeugt wird. Wird <code>VAR</code> weggelassen, so wird ein Wertparameter erzeugt. Beim Aufruf wird der tatsächliche Parameter <code>N</code> übergeben.

{| class="wikitable"
|
! 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 (Programmiersprache)|C]] geschrieben, welche keine Referenzparameter kennt. Durch Benutzung von [[Zeiger (Informatik)|Zeigern]] kann aber ein ähnliches Verhalten realisiert werden.

<syntaxhighlight highlight="5,12" lang="c">
// Uebergabe der Variablen x als Zeigerparameter p in C

#include <stdio.h>

void increment_p(int* p) {
*p += 1;
}

int main() {
int x = 3;

increment_p(&x);
printf("Das Ergebnis ist %d\n", x);

return 0;
}
</syntaxhighlight>

In Zeile 15 wird der Adressoperator <code>&</code> verwendet, so dass die Adresse der Variablen <code>x</code> an die Funktion übergeben wird. Diese wird an den Zeigerparameter<code>p</code> (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:
<syntaxhighlight lang="cpp">
void increment_r(int& r) {
r += 1;
}
</syntaxhighlight>

Im Vergleich dazu noch einmal das Beispiel für Zeiger:
<syntaxhighlight lang="cpp">
void increment_p(int* p) {
*p += 1;
}
</syntaxhighlight>

Bei der Variante <code>increment_r</code> entfallen also die Zeigerdereferenzierungen im Funktionsrumpf.

Aufruf der Funktion:
<syntaxhighlight lang="cpp">
// ...
increment_r(x);
// ...
</syntaxhighlight>

Im Unterschied zu der Variante mit <code>increment_p</code> wird also hier beim Aufruf nicht der [[Adressoperator]] & verwendet.

== Verwendende Programmiersprachen ==
* [[Pascal (Programmiersprache)|Pascal]]
* [[Modula-2]]
* [[Fortran]]
* [[C++]]
* [[PL/I]]
* [[PHP]]

== Siehe auch ==
* [[Wertparameter]], auch ''call by value'' oder ''pass by value'';
* [[Wertergebnisparameter]].

[[Kategorie:Programmiersprachelement]]
[[Kategorie:Programmierparadigma]]

[[en:Call by reference]]

Referenzparameter - Versionsgeschichte

imported>Diaspomod: /* Beispiel */