Wie Zeiger auf Funktionen in C ++ Pass

Eine der Verwendungen von Zeigervariablen in C ++ ist Argumente an Funktionen im Vorübergehen. Um zu verstehen, warum dies wichtig ist, müssen Sie verstehen, wie Argumente an eine Funktion übergeben werden.

Vorbei an Wert in C ++

Standardmäßig werden die Argumente an Funktionen als Wert übergeben. Dies hat den etwas überraschende Ergebnis, daß in Abhängigkeit des Werts einer Variablen zu ändern in die aufrufende Funktion sein Wert normalerweise nicht geändert werden. Betrachten Sie das folgende Beispiel Codesegment:

Leere fn (int Narg) {Narg = 10 - // Wert von Narg an dieser Stelle 10} void parent (void) {int n1 = 0-fn (n1) - // Wert von n1 ist an dieser Stelle noch 0}

hier ist die Elternteil() Funktion initialisiert die Integer-Variable n1 0. Der Wert von n1 Dann wird übergeben fn (). Nach Eingabe der Funktion, Narg gleich 0 ist, übergeben Sie den Wert. fn () ändert den Wert Narg bis 10 vor der Rückkehr in Elternteil(). Nach der Rückkehr in Elternteil(), der Wert von n1 0 ist nach wie vor.

Der Grund für dieses Verhalten ist, dass C ++ keine Variable an eine Funktion. Stattdessen übergibt C ++ den Wert in der Variablen zu der Zeit des Anrufs enthalten. Das heißt, der Ausdruck ausgewertet, selbst wenn es nur ein Variablenname, und das Ergebnis weitergegeben.

In dem Beispiel ist der Wert von n1, die 0 ist, wurde übergeben fn (). Was die Funktion macht mit diesem Wert hat keine Auswirkung auf n1.

Passing Zeigerwerte in C ++

Wie bei jedem anderen intrinsischen Typ, ein Zeiger als Argument an eine Funktion übergeben werden:

Leere fn (int * pnArg) {* pnArg = 10-} void parent (void) {int n = 0-fn (n) - // dies geht die Adresse von i // nun der Wert von n 10}

In diesem Fall wird die Adresse des n an die Funktion übergeben fn () eher als der Wert von n. Die Bedeutung dieser Unterschied wird deutlich, wenn Sie die Zuordnung zu betrachten, innerhalb fn ().

Annehmen n an der Adresse 0x100 entfernt. Eher als der Wert 10, der Anruf fn (n) übergibt den Wert 0x100. Innerhalb fn (), die Zuordnung *pnArg = 10 speichert den Wert 10 in der int Variable an der Stelle befindet 0x100, wodurch das Überschreiben Sie den Wert 0. Nach der Rückkehr in Elternteil(), der Wert von n ist 10, da n ist nur ein anderer Name für 0x100.

Übergabe als Referenz in C ++

C ++ bietet eine Abkürzung für Argumente, die Adresse vorbei - eine Kurz, die Sie mit Zeigern zu Ärger zu vermeiden, ermöglicht. Die folgende Erklärung wird eine Variable n1 und einen zweiten Verweis auf die gleichen n1 aber mit einem neuen Namen, nRef:

int n1 - // deklarieren ein int variableint nRef = n1 - // eine zweite Verweis auf n1nRef erklären = 1 // jetzt die Referenz Zugriff // hat die gleiche Wirkung wie den Zugriff auf n1 - // n1 ist nun gleich 1

Eine Referenzvariable wie nRef müssen initialisiert werden, wenn es, weil jeder späteren Zeitpunkt erklärt wird, dass sein Name verwendet wird, wird C ++ davon ausgehen, dass Sie die Variable bedeuten, dass nRef bezieht sich auf.

Referenzvariablen finden ihre primäre Anwendung in Funktionsaufrufe:

Leere fn (int rnArg) // Referenz Argument deklarieren {rnArg = 10 - // den Wert der Variablen ändern ...} //...that rnArg tovoid Elternteil bezieht (void) {int n1 = 0-fn (n1) - // geben einen Verweis auf n1 // hier der Wert von n1 10}

Das nennt man vorbei Referenz. Die Erklärung int rnArg erklärt rnArg eine Referenz auf ein ganzzahliges Argument. Das fn () Funktion speichert den Wert 10 in die int Lage verwiesen durch rnArg.

Bezug Passing ist die gleiche, die Adresse einer Variablen als vorbei. Die Referenz-Syntax stellt die Last auf C ++ anzuwenden, um die # 147-Adresse von # 148- Bediener auf die Referenz anstatt den Programmierer erforderlich, dies zu tun.

Sie können einen Pass von Wertfunktion mit seinem Pass von Referenz Äquivalent überlasten. So könnte man die beiden Funktionen nicht definieren fn (int) und fn (int) in demselben Programm. C ++ würde nicht wissen, was man zu nennen.