Funktion Gibt die Adresse eines lokalen Variablenfehlers in C++ zurück

1. Funktion Gibt die Adresse eines lokalen Variablenfehlers in C++ zurück
2. Ursache der Funktion Gibt die Adresse einer lokalen Variablen in C++ zurück
3. Beispiele, bei denen die Funktion die Adresse einer lokalen Variablen zurückgibt Fehler treten in C++ auf
4. Abschluss

Basierend auf dem Gültigkeitsbereich werden Variablen in C und C++ in lokale und globale Variablen unterteilt. Während auf die globalen Variablen von jedem Teil des Programms aus zugegriffen werden kann, gilt dies nicht für lokale Variablen.

Daher ist es wichtig, sie sorgfältig zu verwenden, wenn verschiedene Funktionen im Code beteiligt sind. Andernfalls könnte der Fehler Adresse der zurückgegebenen lokalen Variablen auftreten.

Lassen Sie uns besprechen, warum dieser Fehler auftritt und wie er behoben werden kann.

Funktion Gibt die Adresse eines lokalen Variablenfehlers in C++ zurück

Um die Gründe und möglichen Korrekturen für den Fehler Funktion gibt die Adresse der lokalen Variablen zurück zu verstehen, müssen wir wissen, wie eine lokale Variable funktioniert. Lassen Sie uns das zuerst besprechen.

Das Verhalten einer lokalen Variablen in C++

Eine lokale Variable ist eine Variable, die innerhalb einer Funktion definiert ist und nicht außerhalb dieser bestimmten Funktion verwendet werden kann. Mit anderen Worten, es existiert nur innerhalb der Funktion, in der es definiert wurde, und kann von keinem anderen Teil des Programms aus aufgerufen werden.

Und hier ist eine sehr wichtige Information – die Lebensdauer einer lokalen Variablen wird zerstört, sobald die Funktion ihre Ausführung beendet.

Sehen Sie sich dieses Beispiel an. Hier wird die Variable cost innerhalb der Funktion demo() deklariert; daher ist sein Umfang nur auf diese Funktion beschränkt.

Innerhalb des main-Blocks versuchen wir, auf diese lokale Variable zuzugreifen, und deshalb läuft das Programm auf einen Fehler.

So funktioniert im Wesentlichen eine lokale Variable.

#include <iostream>
using namespace std;

void demo() {
  int cost = 5000;
  cout << "The variable cost is local to the demo function." << endl;
}
int main() {
  int cakes = 10;
  demo();
  cout << "Payable amount: " << cost;
}

Ausgang:

In function 'int main()':
error: 'cost' was not declared in this scope
     13 |     cout << "Payable amount: " << cost;
        |                                   ^~~~

Jetzt wissen Sie, dass die Verwendung einer lokalen Variablen außerhalb ihres Gültigkeitsbereichs illegal ist. Lassen Sie uns diskutieren, warum der Fehler Funktion gibt die Adresse der lokalen Variablen zurück auftritt.

Um mehr über lokale Variablen und Funktionen in C++ zu erfahren, lesen Sie diese Dokumentation.

Ursache der Funktion Gibt die Adresse einer lokalen Variablen in C++ zurück

Der Fehler Funktion gibt die Adresse der lokalen Variablen zurück tritt normalerweise bei der Arbeit mit Funktionen und lokalen Variablen auf. So wie wir nicht auf eine lokale Variable außerhalb ihres definierten Bereichs zugreifen können, können wir auch nicht auf ihre Adresse außerhalb dieses Bereichs zugreifen.

Betrachten Sie es so. Wenn Sie versuchen, auf eine lokale Variable außerhalb des definierten Geltungsbereichs zuzugreifen, erhalten Sie den Fehler Variable nicht in diesem Geltungsbereich deklariert, wie im obigen Beispiel zu sehen.

Wenn Sie jedoch versuchen, auf die Adresse einer lokalen Variablen außerhalb des definierten Gültigkeitsbereichs zuzugreifen, erhalten Sie den Fehler Funktion gibt die Adresse der lokalen Variablen zurück.

Hier ist, warum dies geschieht.

Wir wissen, dass eine lokale Variable zerstört wird, sobald die Funktion ihre Ausführung abgeschlossen hat. Das bedeutet, dass der Zeiger, der die Adresse der lokalen Variablen zurückgibt, nun auf ein Objekt zeigt, das gar nicht existiert.

Zeiger auf lokale Variablen können die Funktion, in der sich die lokale Variable befindet, nicht verlassen. Aber wenn dies passiert, können wir sagen, dass sich der Zeiger in einen hängenden Zeiger ändert, und daher erhalten wir den Fehler Funktion gibt die Adresse der lokalen Variablen zurück.

Dieser Fehler kann in verschiedenen Fällen auftreten. Lassen Sie uns sie einzeln besprechen.

Beispiele, bei denen die Funktion die Adresse einer lokalen Variablen zurückgibt Fehler treten in C++ auf

Während die Ursache für all diese Codes, die auf den Fehler Funktion gibt die Adresse der lokalen Variablen zurück laufen, dieselbe ist wie oben beschrieben, lassen Sie uns einige Beispiele im Detail betrachten.

Funktion Gibt einen Zeiger auf eine lokale Variable zurück

Sehen Sie sich den unten angegebenen Code an. Wir haben eine Funktion namens demo(), die zwei ganzzahlige Werte nimmt und sie addiert.

Die Funktion speichert die Summe in der Variablen Kosten und gibt dann die Adresse dieser Variablen zurück. Aber wenn Sie diesen Code ausführen, erhalten Sie den Fehler Adresse der zurückgegebenen lokalen Variablen.

Beachten Sie hier zwei Dinge.

1. Die Variable Kosten wird innerhalb der Funktion demo() definiert; Daher ist sein Umfang auf diese Funktion beschränkt. Es ist eine lokale Variable.
2. Die return-Anweisung gibt einen Zeiger mit der Adresse der lokalen Variablen cost zurück.

Wir wissen, dass, sobald die Funktion demo() ihre Ausführung beendet, auch die darin vorhandene lokale Variable cost zerstört wird. Das bedeutet, dass der Zeiger, der früher auf die Adresse der Variable Kosten zeigte, nun beginnt, auf einen Ort im Gedächtnis zu zeigen, der uns nicht mehr gehört.

Daher erhalten wir diesen Fehler.

#include <iostream>
using namespace std;

int* demo(int cherry, int pie) {
  int cost = cherry + pie;
  return &cost;
}

int main() { int* ans = demo(100, 20); }

Ausgang:

In function 'int* demo(int, int)':
warning: address of local variable 'cost' returned [-Werturn-local-addr]
    7 |    return &cost;
      |           ^~~~~
note: declared here
    6 |    int cost = cherry + pie;
      |        ^~~~

Lassen Sie uns sehen, wie Sie dies beheben können. Das Problem ist, dass die Rücksendeadresse die einer lokalen Variablen ist; Daher hilft die dynamische Speicherzuweisung, dieses Problem zu lösen.

Innerhalb des main-Blocks definieren wir dynamisch die Variable cost und weisen Speicher zu. Dann übergeben wir diese Variable als Parameter an die Funktion demo().

#include <iostream>
using namespace std;

int* demo(int cherry, int pie, int* cost) {
  *cost = cherry + pie;
  return cost;
}

int main() {
  int* cost = new int;
  cost = demo(100, 20, cost);

  cout << "The total is stored at address: " << cost;
}

Ausgang:

The total is stored at address: 0x55c7997a7eb0

Wenn wir diesen Code ausführen, erhalten wir diesmal die richtige Ausgabe. Denn die Variable cost ist keine lokale Variable mehr, da sie ausserhalb der Funktion demo() deklariert wird.

Funktion gibt eine Zeichenfolge zurück, deren Gültigkeitsbereich lokal ist

Sehen Sie sich das folgende Code-Snippet an. Hier nehmen wir einen Namen als Eingabe des Benutzers und prüfen ihn mit der Funktion checkname() auf Gültigkeit.

Innerhalb der Funktion checkname() definieren wir einen String namens fullname und geben ihn zurück, wenn er die Prüfbedingung erfüllt. Aber der Code läuft auf den Fehler Funktion gibt die Adresse der lokalen Variablen zurück.

Hier ist, warum dies geschieht.

Wir haben einen String namens fullname, dessen Geltungsbereich auf die Funktion checkname() beschränkt ist. Außerdem ist ein String wie ein Array, das auf einen Zeiger reduziert wird, bevor es übergeben werden kann.

Wenn wir zum Haupt-Block zurückkehren, werden die lokalen Variablen der Funktion zerstört, weil die Steuerung diese Funktion verlassen hat.

Deshalb bekommen wir den Fehler.

#include <cstring>
#include <iostream>
using namespace std;

char* checkname() {
  char fullname[20];
  //....
  //......
  //....
  if ((strlen(fullname)) >= 4 && (strlen(fullname)) < 30) {
    return fullname;
  } else {
    return NULL;
  }
}

int main(void) {
  char name[20];
  cout << "Enter name:" << endl;
  name = checkname();
}

Ausgang:

warning: address of local variable 'fullname' returned [-Wreturn-local-addr]

Um dies zu beheben, übergeben Sie die Daten, anstatt sie zurückzugeben, wie folgt an die Funktion:

#include <cstring>
#include <iostream>
using namespace std;

void checkname(char *fullname) {
  if ((strlen(fullname)) >= 4 && (strlen(fullname)) < 30) {
    cout << "Success";
  } else {
    cout << "In else block";
  }
}

int main(void) {
  char name[20];
  cout << "Enter name:" << endl;
  checkname(name);
}

Ausgang:

Enter name:
In else block

Sehen Sie, der Code läuft dieses Mal gut, und da wir keine Eingaben gemacht haben, gehen wir in den else-Block.

Während dies das Problem löst, wäre eine robustere Lösung, den Speicher dynamisch der Variablen fullname wie folgt zuzuweisen:

char *fullname = malloc(sizeof(char) * the_size);
.......return fullname;

Wenn wir Speicher dynamisch zuweisen, wird er vom Heap zugewiesen, dessen Lebensdauer bis zur Ausführung des gesamten Programms gültig ist. Wenn wir also jetzt die Variable fullname zurückgeben, erhalten wir die durch malloc definierte Adresse, und der Code läuft einwandfrei.

Auch das Freigeben des Speichers, sobald dies geschehen ist, ist eine gute Vorgehensweise, um Speicherlecks zu vermeiden.

Abschluss

In diesem Artikel wurde der Fehler Funktion gibt die Adresse einer lokalen Variablen zurück in C++ behandelt. Wir haben gelernt, wie sich lokale Variablen verhalten und dass der Versuch, außerhalb ihres Gültigkeitsbereichs auf sie zuzugreifen, illegal ist.

Wir haben die Gründe für diesen Fehler und die möglichen Lösungen anhand einiger Anwendungsfälle gesehen.