Call by Reference

[dietz]

Hallo!

Kann mir jemand die Übergabe von Variablen mit "Call by Reference" verständlich erklären?
Call by Value heisst ja der Compiler legt eine "Kopie" der Variablen an, und bei Call by Reference macht der Compiler irgentwas mit der Speicheradresse oder? *nichtganzverstehwiedasfunktioniert*

Danke für eure Hilfe schon mal im voraus!

[RaistlinMajere]

bei einer call-by-reference zuweisung wird einer variable derselbe platz im speicher zugewiesen, wie einer anderen, du hast also quasi 2 verweise auf ein und dieselbe speicheradresse. ansonsten, bei einer normalen zuweisung hättest du 2 variablen, die beide eine eigene speicheradresse benötigen.
frag mich jetzt bloß nicht, wann man sowas braucht.

[dietz]

Ich hab da was....

Call by Value:
Wenn man eine Prozedur aufruft und dabei eine Variable (Argument) an diese Prozedur übergibt, kopiert das Programm den Wert der übergebenen Daten in eine neu erzeugte Variable. Für jedes Argument einer Prozedur erzeugt der Compiler eine separate lokale Variable.

Bei Call by Reference erzeugt der Compiler auch eine Variable, in der er aber nicht den übergebenen Wert wie bei Call by Value sondern die Adresse der übergebenen Variable im Speicher kopiert.
Wenn ich für ein Argument dieses Call by Reference verwende muß ich das Argument dann auch anders deklarieren oder?

Jetzt stellt sich wirklich die Frage für was das jetzt gut ist? Weiß das jemand?

[helios]

Wie gesagt:
Übergibst du eine Variable by Value, wird eine Kopie angelegt und das Unterprogramm arbeitet mit dieser Kopie. Jede Änderung die das Unterprogramm an dieser Kopie vornimmt hat keine Auswirkung auf die eigentliche Variable im Hauptprogramm (die Kopie wird beim Verlassen es Unterpgrogrammes im Normalfall wieder gelöscht).
Anders bei Übergabe by Reference. Hier wird keine Kopie angelegt sondern nur die Adresse der Variable aus dem Hauptprogramm übergeben. Das heisst, auch das Unterprogramm arbeitet mit der Variable aus dem Hauptprogramm, auch wenn diese Variable im Unterpgrogramm unter einem anderen Namen (dem Parameternamen) bekannt ist. Somit hat jede Änderung die das Unterprogramm an dieser Variable vornimmt auch Auswirkungen auf das Hauptprogramm.

Beide Varianten haben Vor- u. Nachteile, Call by Value ist aber die üblichere u. ungefährlichere Methode.

[RaistlinMajere]

wenn sich eine variable, die per call by reference übergeben wurde, ändert, daß sich dann dann auch die andere ändert, die sind also quasi miteinander verknüpft, weil sie ein und dieselbe speicheradresse benutzen, sehe ich das richtig? riskante sache bei größeren programmen, sage ich, aba solange man nicht den überblick verliert, kanns schon mal was bringen (abgesehen von speicherersparnis, aber das spielt wohl die geringste rolle dabei).

[kikakater]

1) Call by Value: Übergabe des Wertes einer Variablen
2) Call by Reference: Übergabe der Adresse einer Variablen, Arbeiten innerhalb der Unterroutine wie mit einer Datenvariablen IM GEGENSATZ zu einer Zeigervariablen
3) Call by Address: Übergabe der Adresse einer Variablen

Also:

a) Aufruf der C-Funktion "unterprogramm":

ad 1: int i=400;
unterprogramm(i); /* Übergabe des Wertes von i (also dem dezimalen Wert 400) über den Stack an die Funktion "unterprogramm" */

ad 2: int i=400;
unterprogramm(i); /* Übergabe der Referenz (=Adresse) von i, implizit die Adresse von i */

ad 3: int i=400;
unterprogramm(&i); /* Übergabe der (Zeiger-) Adresse von i, explizit die Adresse von i */


b) Ausdefinition der C-Funktion "unterprogramm":

ad 1:
int unterprogramm(int value) /* Variablenwert liegt auf dem Stack */
{
if(value==400) return value * 2;
if(value<400) value=0; /* hat keinen Effekt auf die Variable i, insofern ist das ein versteckter Fehler falls i außerhalb verändert werden sollte */
}

ad 2:
int unterprogramm(int& outervariable) /* Referenz(=Adresse der Variable) liegt auf dem Stack */
{
if(outervariable==400) return outervariable * 2;
if(outervariable<400) outervariable=0; /* i wird verändert, outervariable und i haben die gleiche Speicheradresse */
}

ad 3:
int unterprogramm(int *pointer) /* Adresse (einer int Variablen) liegt auf dem Stack */
{
if(*pointer==400) return *pointer * 2; /* i wird über * auf i verändert, "i" ist "*pointer" in diesem Fall bzw. "*pointer" ist "i" besser gesagt */
if(*pointer<400) *pointer=0; /* i wird über *pointer= verändert */
}

Während 2. und 3. vom Speicherzugriff gleich sind und direkt auf die Variable der aufrufenden Funktion wirken, beschränkt sich 1. auf die Parametervariable value, es handelt sich um eine echte "Wert"-Kopie einer Integer-Variablen.

Call by Reference ist dazu da um den Zugriff auf Variablen innerhalb einer UNTERROUTINE genauso zu ermöglichen, als ob die Anweisungen in der aufrufenden Routine stehen würden.

Also statt *pointer= kann man value= benutzen in dieser Unterroutine, anstatt einen Wert zu übergeben, wird die Adresse ... die Referenz .. die Referenzadresse ... der Variablen übergeben und syntaxmäßig aber wie mit einer Wertvariablen und eben nicht wie mit einer Zeigervariablen gearbeitet.

Bei einer 2 Byte int Variable scheint die Sache Call by Reference unwirtschaftlicher zu sein - ist sie im Übrigen auch - es werden 4 Bytes statt 2 auf dem Stack übergeben.

Der erste Vorteil liegt in der gleichen Schreibweise wie bei einer Wertvariablen und bei der unmittelbaren Veränderung der übergebenen Variable selbst.

Der zweite Vorteil liegt in der Übergabe einer Adresse wie bei einer Pointervariante dieser Funktion - also "int unterprogramm(int *pointer)" - und nicht - wenn es sich beim Funktionsparameter um eine Struktur handeln würde - z.B. einer 456 Byte großen Struktur ... SOWIE ... dem bequemen Ansprechen als Datenvariable und nicht Zeigervariable + Sternbackreferencing auf ein Datum (=grammatikalische Einzahl des Wortes "Daten", nicht notwendigerweise ist damit ein Tagesdatum gemeint).

Es wird deshalb nicht diese gesamte Länge von 456 Bytes (="der Wert" der Struktur) auf dem Stack mitgegeben, sondern nur die Adresse der Struktur, arbeiten tut die Funktion dann also trotz vermeintlicher syntaxmäßiger Wertkopie-Verwendung eines Funktionsparameters mit der übergebenen Struktur(adresse) direkt.

pointer_auf_struktur->membervariable= 1234; entfällt somit und lautet nun referenz_auf_struktur.membervariable= 1234; in der Funktion mit dem Funktionskopf int funktion(struct struktur& referenz_auf_struktur) .

Call by reference ist von der Syntax (=Grammatik) her wie die Verwendung einer Wertvariablen und semantisch (bedeutungsmäßig) ein Zugriff über Adresse auf die außerhalb der Funktion gelegene Variable.

mfg Kikakater

[dietz]

Vielen Dank für eure Hilfe, dieses Thema mit der Variablenübergabe ist mir jetzt endlich klar geworden. Muß schon sagen Ihr kennt euch gut aus!
Kennt Ihr vielleicht noch gute Links oder gute Literatur wo ich über Variablen nachlesen kann?

MfG dietz