Funktionsaufruf durch Referenz in C

Hallo da draußen, zukünftige Programmierer! Heute machen wir uns auf eine aufregende Reise in die Welt der C-Programmierung und erkunden das Konzept des "Funktionsaufrufs durch Referenz". Keine Sorge, wenn du neu im Programmieren bist; ich werde dich Schritt für Schritt durchführen, genau wie ich es in den letzten Jahren für unzählige Schüler getan habe. Also hole dir dein Lieblingsgetränk, setze dich bequem hin, und tauchen wir ein!

Der Adressoperator (&) in C

Bevor wir Funktionsaufrufe durch Referenz verstehen können, müssen wir uns mit einem sehr wichtigen Symbol in C vertraut machen: dem Ampersand (&). Dieses kleine Zeichen wird als "Adressoperator" bezeichnet und ist wie eine magischestab, der die geheime Lage unserer Variablen im Speicher des Computers enthüllt.

Sehen wir uns ein einfaches Beispiel an:

#include <stdio.h>

int main() {
int alter = 25;
printf("Der Wert von alter ist: %d\n", alter);
printf("Die Adresse von alter ist: %p\n", &alter);
return 0;
}

In diesem Code drucken wir nicht nur den Wert von alter (der 25 ist), sondern auch seine Speicheradresse aus. Der %p-Formatbezeichner wird verwendet, um Speicheradressen auszugeben.

Wenn du dieses Programm ausführst, könntest du etwas wie folgendes sehen:

Der Wert von alter ist: 25
Die Adresse von alter ist: 0x7ffd5e8e9944

Diese seltsam aussehende Zahl nach "Die Adresse von alter ist:" ist tatsächlich eine Speicheradresse! Es ist der Ort, an dem dein Computer sich entschieden hat, die Variable alter zu speichern. Denke daran als die Heimatadresse der Variable in der großen Nachbarschaft des Speichers deines Computers.

Was ist ein Zeiger in C?

Nun, da wir wissen, wie man die Adresse einer Variablen findet, lassen wir uns über Zeiger unterhalten. Wenn die Adresse wie eine Heimatadresse ist, dann ist ein Zeiger wie ein GPS-Navigator, der dich zu dieser Adresse führen kann.

In C ist ein Zeiger eine Variable, die die Speicheradresse einer anderen Variable speichert. Wir deklarieren einen Zeiger, indem wir das Sternchen-Symbol (*) verwenden.

Hier ist ein Beispiel:

#include <stdio.h>

int main() {
int alter = 25;
int *zeiger_alter = &alter;

printf("Der Wert von alter ist: %d\n", alter);
printf("Die Adresse von alter ist: %p\n", &alter);
printf("Der Wert von zeiger_alter ist: %p\n", zeiger_alter);
printf("Der Wert, auf den zeiger_alter zeigt, ist: %d\n", *zeiger_alter);

return 0;
}

In diesem Code ist zeiger_alter ein Zeiger, der die Adresse von alter speichert. Wenn wir *zeiger_alter verwenden, fragen wir nach dem Wert an der Adresse, auf die zeiger_alter zeigt.

Die Ausgabe könnte so aussehen:

Der Wert von alter ist: 25
Die Adresse von alter ist: 0x7ffd5e8e9944
Der Wert von zeiger_alter ist: 0x7ffd5e8e9944
Der Wert, auf den zeiger_alter zeigt, ist: 25

Siehst du, wie die Adresse in zeiger_alter mit der Adresse von alter übereinstimmt? Das liegt daran, dass zeiger_alter auf alter zeigt!

Wie funktioniert der Funktionsaufruf durch Referenz in C?

Nun, da wir Zeiger verstehen, können wir den Funktionsaufruf durch Referenz erkunden. Wenn wir eine Funktion durch Referenz aufrufen, übergeben wir die Adresse einer Variablen an die Funktion,而不是 ihren Wert. Dies ermöglicht es der Funktion, die ursprüngliche Variable direkt zu modifyieren.

Sehen wir uns ein Beispiel an:

#include <stdio.h>

void erhöhen(int *nummer) {
(*nummer)++;
}

int main() {
int x = 5;
printf("Vor Erhöhung: x = %d\n", x);
erhöhen(&x);
printf("Nach Erhöhung: x = %d\n", x);
return 0;
}

In diesem Code übergeben wir die Adresse von x an die Funktion erhöhen. Die Funktion verwendet diese Adresse, um den Wert von x direkt zu modifyieren.

Die Ausgabe wird sein:

Vor Erhöhung: x = 5
Nach Erhöhung: x = 6

Die Funktion erhöhen konnte den Wert von x in der Funktion main modifyieren, weil sie die Adresse von x erhalten hat, nicht nur eine Kopie ihres Wertes.

Mischen von Wertübergabe und Referenzübergabe

In C können wir Wertübergabe und Referenzübergabe in der gleichen Funktion mischen. Dies kann nützlich sein, wenn wir einige Parameter modifyieren möchten, aber nicht andere.

Hier ist ein Beispiel:

#include <stdio.h>

void modify(int *a, int b, int *c) {
(*a)++;
b++;
(*c)++;
}

int main() {
int x = 1, y = 2, z = 3;
printf("Vor modify: x = %d, y = %d, z = %d\n", x, y, z);
modify(&x, y, &z);
printf("Nach modify: x = %d, y = %d, z = %d\n", x, y, z);
return 0;
}

In diesem Beispiel werden x und z per Referenz übergeben, während y per Wert übergeben wird.

Die Ausgabe wird sein:

Vor modify: x = 1, y = 2, z = 3
Nach modify: x = 2, y = 2, z = 4

Beachte, wie x und z geändert wurden, aber y gleich geblieben ist? Das liegt daran, dass die Funktion nur eine Kopie des Wertes von y erhalten hat, nicht deren Adresse.

Hier ist eine Tabelle, die die Unterschiede zwischen Wertübergabe und Referenzübergabe zusammenfasst:

Aspekt	Wertübergabe	Referenzübergabe
Was wird übergeben	Kopie des Wertes	Adresse der Variablen
Kann das Original modifyieren	Nein	Ja
Syntax	funktion(variable)	funktion(&variable)
Funktionparameter	Normale Variable	Zeiger

Und das war's! Wir haben die Grundlagen des Funktionsaufrufs durch Referenz in C behandelt. Erinnere dich daran, dass wie bei jeder neuen Fähigkeit, Übung der Schlüssel ist. Versuche, deine eigenen Funktionen zu schreiben, die Referenzaufrufe verwenden, und experimentiere mit verschiedenen Szenarien. Bereit zum Programmieren, und möge deine Zeiger immer in die richtige Richtung zeigen!

Credits: Image by storyset