Bei der Verwendung von GDB kann jedoch der Fehler „Fehler: GDB kann an der Adresse nicht auf den Speicher zugreifen“ auftreten. Dieser Fehler kann verwirrend sein und es schwierig machen, mit dem Debuggen fortzufahren. Der Schwerpunkt dieses Artikels liegt darauf, herauszufinden, warum dieser Fehler auftritt, und einige Codebeispiele zu betrachten, die uns helfen, zu verstehen, wie dieser Fehler behoben werden kann.
Beispiel 1:
Sehen wir uns unser erstes Codebeispiel an, das bei der Ausführung den Fehler „GDB kann an der Adresse nicht auf den Speicher zugreifen“ ausgibt. Zuerst schauen wir uns den Code an. Dann werden wir die zeilenweise Erklärung dazu sehen.
#include
verwenden Namensraum std ;
int hauptsächlich ( Leere ) {
int * P ;
cout << * P ;
}
Das Programm beginnt mit der Deklaration der Präprozessoranweisung „#include
Innerhalb der Hauptfunktion wird die Zeigervariable „*p“ deklariert. Hier wird die Variable „p“ nicht initialisiert. Daher zeigt es nicht auf einen bestimmten Speicherort, der für die Ganzzahl reserviert ist. Diese Zeile verursacht einen Fehler, den wir später beheben werden. In der nächsten Zeile versuchen wir, den Wert der Variablen „*p“ mithilfe der Anweisung „cout“ auszugeben.
Da die Variable „p“ ein Zeiger vom Typ Integer ist, wird das Sternchen „*“ verwendet, um sie zu dereferenzieren. Das bedeutet, dass sich der Wert an der Speicherstelle befindet, auf die er zeigt. Da der „p“-Zeiger jedoch nicht initialisiert wurde und nicht auf eine bestimmte und gültige Position zeigt, führt die Dereferenzierung des Zeigers zu undefiniertem Verhalten. Daher kommt es je nach System und Compiler zur Generierung verschiedener Arten von Fehlern. Da wir den GDB-Compiler zum Debuggen und Ausführen dieses Programms verwenden, gibt der Debugger den folgenden Fehler aus. Der Fehler wird im Ausgabe-Snippet angezeigt:
Wie Sie in der Ausgabe sehen können, kann der Debugger nicht auf den Speicher zugreifen. Dieses Programm dereferenziert einen nicht initialisierten Zeiger, der Hauptgrund für dieses undefinierte Verhalten. Sehen wir uns nun an, wie wir dieses Problem lösen können. Der richtige Code ist im Folgenden angegeben. Schauen Sie es sich an und wir erklären Ihnen, wie wir den Fehler im Code beheben:
#include
verwenden Namensraum std ;
int hauptsächlich ( Leere ) {
int val = 5 ;
int * P = & val ;
cout << „Der Wert ist =“ << * P ;
}
Wie Sie sehen können, wird der Code durch die Einfügung von „int val =5;“ geändert. Stellungnahme. Diese Zeile deklariert eine ganzzahlige Variable mit dem Namen „val“ und initialisiert sie mit dem Wert „5“. Die nächste Zeile, „int *p = &val;“, deklariert eine „*p“-Zeigervariable und wird so initialisiert, dass sie auf die Adresse der „val“-Variable zeigt. Zuvor zeigte der „*p“-Zeiger auf keine Speicheradresse, was zur Meldung „Kann nicht auf Speicher an Adresse 0x0 zugreifen“ führte.
Um dieses Problem zu lösen, wird die Variable „var“ deklariert, initialisiert und dem Zeiger „*p“ zugewiesen. Jetzt zeigt der „*p“-Zeiger auf die Adresse der „val“-Variablen, da der „&“-Operator die Adresse von „val“ nimmt und sie „p“ zuweist. Auch hier wird die „cout“-Anweisung verwendet, um den Wert des „*p“-Zeigers auszugeben. Sehen Sie sich den folgenden Ausgabeausschnitt an, um den Wert von „val“ zu sehen, auf den der „*p“-Zeiger zugreift:
Wie Sie sehen können, wurde der Fehler behoben und der Wert „5“ initialisiert, da die Variable „val“ durch den Aufruf des „*p“-Zeigers valribale gedruckt wurde.
Beispiel 2:
Betrachten wir ein weiteres Beispiel, das erklärt, wie man den Fehler „GDB kann nicht auf den Speicher an der Adresse zugreifen“ im C++-Codeprogramm beheben kann. Der Code wird im Folgenden als Referenz angegeben. Guck mal:
#includeint hauptsächlich ( ) {
int * P = neu int [ fünfzehn ] ;
löschen [ ] P ;
std :: cout << P [ 2 ] << std :: endl ;
zurückkehren 0 ;
}
Eines der häufigsten Szenarios, auf die Entwickler beim Programmieren mit Zeigern stoßen, ist die falsche oder falsche Speicherzuweisung. Die GDB führt immer dann zu dem Fehler, wenn in einem C++-Programm eine falsche Speicherzuweisung und -freigabe auftritt.
Betrachtet man das vorherige Codebeispiel, wird ein „*p“-Zeiger mit einem neuen int[15] initialisiert. Diese Anweisung weist mithilfe des neuen Operators dynamisch ein Array mit 15 Ganzzahlen zu. Die Zeigervariable „*p“ speichert die Speicheradresse des Arrays.
In der folgenden Anweisung gibt „delete[] p;“ an, dass der Speicher mit dem Befehl delete[] freigegeben wurde. Der Befehl delete[] gibt den zuvor zugewiesenen Speicher des „*p“-Zeigers frei, was bedeutet, dass das andere System den zuvor zugewiesenen Speicherblock erneut zuweisen kann. Wenn wir versuchen, den Wert der Variablen „*p“ mit der Anweisung „cout“ auszugeben, erhalten wir den Speicherzugriffsfehler, wie in der folgenden Ausgabe zu sehen ist:
Beachten Sie dabei, dass die genaue Fehlermeldung je nach GDB-Version und System leicht abweichen kann. Aber der „Fehler: GDB kann am Speicherort nicht auf den Speicher zugreifen“ und der angegebene Fehler im vorherigen Snippet sind identisch. Um diesen Fehler zu beheben, verschieben wir einfach den Befehl delete[] nach der „cout“-Anweisung. Sehen Sie sich den geänderten Code im Folgenden an:
#includeint hauptsächlich ( ) {
int * P = neu int [ fünfzehn ] ;
für ( int ich = 0 ; ich < fünfzehn ; ++ ich ) {
P [ ich ] = ich * 2 - 5 + 8 ;
std :: cout << 'P[' << ich << '] = ' << P [ ich ] << std :: endl ;
}
löschen [ ] P ;
zurückkehren 0 ;
}
Hier sehen Sie, dass wir das Array mit Werten initialisiert haben, die zur Laufzeit berechnet werden, und alle Werte der Schleife mithilfe der „for“-Schleife drucken. Das Wichtigste, was hier zu beachten ist, ist die Verschiebung der delete[]-Anweisung; Es wird nun aufgerufen, nachdem alle Werte des Arrays abgerufen wurden, wodurch der Speicherzugriffsfehler behoben wurde. Sehen Sie sich die endgültige Ausgabe des Codes im Folgenden an:
Abschluss
Zusammenfassend lässt sich sagen, dass der Fehler „Fehler: GDB kann an der Adresse nicht auf den Speicher zugreifen“ normalerweise auf speicherbezogene Probleme im C++-Code hinweist. In diesem Artikel wurden einige häufige Szenarios untersucht, die diesen Fehler auslösen, um zu erklären, wann und wie er behoben werden kann. Wenn dieser Fehler im Code auftritt, ist es wichtig, ihn sorgfältig zu überprüfen und dabei genau auf die Zeigervariablen, Speicherzuordnungen, Arrays und Strukturen zu achten.
Darüber hinaus können von GDB bereitgestellte Funktionen wie Haltepunkte beim Auffinden des Fehlers beim Debuggen des Programms hilfreich sein. Diese Funktionen können dabei helfen, den genauen Ort von speicherbezogenen Fehlern zu lokalisieren. Indem Entwickler diese Probleme proaktiv angehen, können sie die Stabilität und Zuverlässigkeit ihrer C++-Anwendungen verbessern.