Gibt die Referenz einer lokalen Variablen den Wert oder die Adresse zurück (und warum ist das gefährlich)?

Rätsel der Referenzierung lokaler Variablen: Wert oder Adresse zurückgeben?

Viele Programmierer gehen möglicherweise davon aus, dass die Rückgabe von Referenzen auf lokale oder temporäre Variablen in Funktionen fehlerhaft ist , was zu undefiniertem Verhalten führt. In bestimmten Situationen kann es jedoch überraschend erfolgreich sein und den Wert der Variablen ändern. Lassen Sie uns dieses Phänomen anhand eines anschaulichen Codebeispiels untersuchen:

#include <iostream>

int& foo() {
    int i = 6;
    std::cout << &i << std::endl; // Prints the address of i before return
    return i;
}

int main() {
    int i = foo();
    std::cout << i << std::endl; // Prints the value
    std::cout << &i << std::endl; // Prints the address of i after return
}

Wenn wir diesen Code ausführen, beobachten wir merkwürdiges Verhalten:

1. Die Adresse der lokalen Variablen i in foo() wird vor der Rückgabe gedruckt und zeigt damit an, dass sie im Stapelrahmen vorhanden ist.
2. Obwohl i eine lokale Variable in foo() ist, wird ihr Wert erfolgreich geändert, wenn wir den Rückgabewert a zuweisen Variable in main().
3. Die Adresse von i in main() bleibt vor und nach der Rückkehr gleich, was darauf hindeutet, dass sich die Variable immer noch im Stapelspeicher befindet.

Erklären des Vorkommens

Dieses rätselhafte Verhalten kann auf eine Eigenart in der Art und Weise zurückgeführt werden, wie Stapelrahmen in vielen Implementierungen gehandhabt werden. Bei der Rückkehr von einer Funktion wird der Stapelrahmen zunächst nicht sofort gelöscht.

In diesem Beispiel ist der Rückgabetyp int&, was bedeutet, dass die Funktion einen Verweis auf die Adresse von i zurückgibt. Die Zuweisung int i = foo(); in main() speichert die Adresse von i in foo() in der Variablen i in main().

Gleichzeitig gibt die Rückgabeanweisung in foo() den Stapelrahmen nicht sofort frei. Dadurch existiert die Variable i immer noch im Stapelspeicher, obwohl sie hätte zerstört werden sollen. Dadurch kann ich nach der Rückkehr durch seine Referenz geändert werden.

Vorsichtsmaßnahmen und Implikationen

Obwohl dieses Verhalten praktisch erscheinen mag, ist es extrem gefährlich und unzuverlässig. Sich auf die verzögerte Stapelrahmenzerstörung zu verlassen, ist ein Rezept für undefiniertes Verhalten.

In wohldefiniertem Code sollten Sie sicherstellen, dass lokale Variablen im Bereich ihrer definierenden Funktion bleiben und bei ihrer Beendigung umgehend zerstört werden. Andernfalls kann es zu unvorhersehbaren Folgen und Fehlern kommen.

Das obige ist der detaillierte Inhalt vonGibt die Referenz einer lokalen Variablen den Wert oder die Adresse zurück (und warum ist das gefährlich)?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!