Twitter und Facebook-Anbindung
X
Tweet Follow @twitterapi
!!! Anbindung an twitter und facebook öffnen !!!

Wenn Ihnen mein Online-Buch gefällt,
dann bedanken Sie sich doch mit einer kleinen Spende...

5.4 call-by-reference

5.4 call-by-reference

Manchmal ist es vonnöten, dass Funktionen mehrere Werte zurück geben können müssen. Dies geht aber nicht. Von daher hat man sich etwas anderes überlegt. Man übergibt nicht nur die Werte der Variablen, sondern gleich die Adressen bzw. die Referenz der Variable. Somit ist die Funktion in der Lage die Originalwerte zu manipulieren. Die Funktion erzeugt also keine Kopie. (allerdings dürfen die zwei verfahren gemischt werden, aber das lasse ich hier weg). Sie haben dieses Prinzip bereits bei der Funktion "scanf" kennen gelernt. Streng genommen passierte da zwar etwas anderes, aber um es sich vorstellen zu können was im Hintergrund passiert, reicht der Vergleich.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
					
// Addiert die zwei übergebenen Werte, addiert eins drauf und gibt Ergebnis zurück
int AddiereUndPlus1(int &iSummand1, int &iSummand2) {
	// Auffällig ist hier, dass vor dem Namen der Variablen noch so ein & steht. Wir
	// greifen jetzt mit iSummand1 direkt auf iZahl1 zu und können ihren Wert
	// manipulieren. Das Gleiche gilt für iSummand2 und iZahl2. iSummand1 und iSummand2
	// sind jetzt also keine neuen Variablen sondern ein (vereinfacht) "Alias"
	
	int iErgebnis	= iSummand1 + iSummand2;
	iSummand1	+= 1;
	iSummand2++;	// sieht anders aus wie die Zeile darüber, macht aber das gleiche
	
	printf("In der Funktion:\n");
	printf("%i\n", iSummand1);
	printf("%i\n", iSummand2);

	return iSummand1 + iSummand2;
} // AddiereUndPlus1 //////////////////////////////////////////////////////////



// DIESE FUNKTION WIRD IN JEDEM FALL ZUERST AUFGERUFEN ////////////////////////
int main(int argc, char** argv) {
	int iZahl1 = 10;
	int iZahl2 = 20;

	printf("Vor dem Aufruf:\n");
	printf("%i\n", iZahl1);
	printf("%i\n", iZahl2);

	AddiereUndPlus1(iZahl1, iZahl2);	// Die Funktion gibt zwar was zurück, aber den Wert
						// brauchen wir jetzt nicht

	printf("Nach dem Aufruf:\n");
	printf("%i\n", iZahl1);
	printf("%i\n", iZahl2);

	return 0;
} // main /////////////////////////////////////////////////////////////////////
					

Ausgabe:

Vor dem Aufruf:
10
20
In der Funktion:
11
21
Nach dem Aufruf:
11
21
		

Wie Sie jetzt anhand der Ausgabe sehen, war die Funktion in der Lage, die übergebenen Variablen so zu verändern, dass diese Änderung auch nach der Funktion ersichtlich ist. Im Gegensatz zu "scanf", stand der "&" Operator allerdings nicht beim Funktionsaufruf, sondern im Funktionskopf bei der Parameterdeklaration. Nach außen hin, passiert das Gleiche, aber wie erwähnt, macht es intern schon einen Unterschied. Dies verdeutlicht noch einmal folgende Grafik.

Programmablauf und Speicherabbild bei call-by-reference

Der erste Kasten sieht wie vorhin aus, denn in der Funktion "main" ist alles wie gehabt.

Nach dem Funktionsaufruf sieht die Sache aber etwas anders aus. Es wird wieder die Rücksprungadresse auf den Stack gepackt, aber dieses Mal wird nur noch die Variable "iErgebnis" neu erzeugt. Da wir jetzt eine Referenz übergeben haben, kann der Computer jetzt mit den ursprünglichen Variablen arbeiten. Dies verdeutlicht der zweite Kasten.

Nachdem wieder die Berechnungen durchgeführt wurden, sieht der Speicher wie im dritten Kasten aus und das erklärt wiederum die Ausgaben in den Zeilen 11 bis 13. Beachten Sie bitte, dass hier tatsächlich die Originalvariablen manipuliert werden. Sie werden in der Funktion lediglich durch eine Art Alias angesprochen.

Nach dem Funktionsaufruf springt der Computer wieder in die entsprechende Zeile und alle nicht mehr benötigten Variablen werden wieder entfernt. Dies zeigt Kasten vier und erklärt auch die Ausgaben in den Zeilen 33 bis 35.

Zum Seitenanfang
Zum Inhaltsverzeichnis

© Copyright by Thomas Weiß, 2009 - 2012