Wanneer u GDB gebruikt, kunt u echter de foutmelding 'Fout: GDB heeft geen toegang tot geheugen op adres' tegenkomen. Deze fout kan verwarrend zijn en maakt het moeilijk om door te gaan met foutopsporing. Dit artikel is gericht op het identificeren van de reden waarom deze fout optreedt en het bekijken van enkele codevoorbeelden die ons helpen begrijpen hoe deze fout kan worden opgelost.
Voorbeeld 1:
Laten we ons eerste codevoorbeeld bekijken dat bij uitvoering de foutmelding 'GDB heeft geen toegang tot geheugen op adres' geeft. Eerst kijken we naar de code. Vervolgens zullen we de uitleg ervan regel voor regel zien.
#include
gebruik makend van naamruimte soa ;
int voornaamst ( leegte ) {
int * P ;
uit << * P ;
}
Het programma begint met de declaratie van de preprocessorrichtlijn “#include
Binnen de hoofdfunctie wordt de pointervariabele “*p” gedeclareerd. Hier wordt de variabele “p” niet geïnitialiseerd. Het verwijst dus niet naar een specifieke geheugenlocatie die is gereserveerd voor het gehele getal. Deze regel veroorzaakt een fout die we later zullen oplossen. In de volgende regel proberen we de waarde van de variabele “*p” af te drukken met behulp van de instructie “cout”.
Omdat de “p”-variabele een pointer van het type geheel getal is, wordt de asterisk “*” gebruikt om de verwijzing ervan te derefereren. Dit betekent dat de waarde zich op de geheugenlocatie bevindt waarnaar deze verwijst. Omdat de “p”-aanwijzer echter niet is geïnitialiseerd en niet naar een specifieke en geldige locatie verwijst, zal het derefereren van de aanwijzer resulteren in ongedefinieerd gedrag. Daarom resulteert dit in het genereren van verschillende soorten fouten, afhankelijk van het systeem en de compiler. Omdat we de GDB-compiler gebruiken om dit programma te debuggen en uit te voeren, zal de debugger de volgende fout genereren. De fout wordt weergegeven in het uitvoerfragment:
Zoals u in de uitvoer kunt zien, heeft de debugger geen toegang tot het geheugen. Dit programma derefereert een niet-geïnitialiseerde aanwijzer, de belangrijkste reden voor dit ongedefinieerde gedrag. Laten we nu eens kijken hoe we dit probleem kunnen oplossen. De juiste code vindt u hieronder. Bekijk het en we zullen uitleggen hoe we de bug in de code oplossen:
#include
gebruik makend van naamruimte soa ;
int voornaamst ( leegte ) {
int val = 5 ;
int * P = & val ;
uit << 'De waarde is = ' << * P ;
}
Zoals je kunt zien, is de code aangepast door de “int val =5;” op te nemen. stelling. Deze regel declareert een integer-variabele met de naam “val” en initialiseert deze met de waarde “5”. De volgende regel, “int *p = &val;”, declareert een “*p” pointervariabele en wordt geïnitialiseerd om naar het adres van de “val” variabele te verwijzen. Voorheen verwees de “*p”-aanwijzer naar geen enkel geheugenadres, wat ervoor zorgde dat “geen toegang heeft tot het geheugen op adres 0x0”.
Om dit probleem op te lossen, wordt de variabele “var” gedeclareerd, geïnitialiseerd en toegewezen aan de “*p”-aanwijzer. Nu wijst de “*p”-aanwijzer naar het adres van de “val”-variabele terwijl de “&”-operator het adres van “val” neemt en dit toewijst aan “p”. Opnieuw wordt de instructie “cout” gebruikt om de waarde van de “*p”-aanwijzer af te drukken. Zie het volgende uitvoerfragment om de waarde te zien van de “val” waartoe de “*p”-aanwijzer toegang heeft:
Zoals u kunt zien, is de fout opgelost en wordt de waarde van “5” geïnitialiseerd sinds de variabele “val” is afgedrukt door de “*p”-aanwijzer valribale aan te roepen.
Voorbeeld 2:
Laten we nog een voorbeeld bekijken dat uitlegt hoe om te gaan met de fout ‘GDB heeft geen toegang tot geheugen op adres’ in het C++-codeprogramma. De code wordt hieronder ter referentie gegeven. Even kijken:
#includeint voornaamst ( ) {
int * P = nieuw int [ vijftien ] ;
verwijderen [ ] P ;
soa :: uit << P [ 2 ] << soa :: eindl ;
opbrengst 0 ;
}
Een van de meest voorkomende scenario's die ontwikkelaars tegenkomen tijdens het programmeren met pointers is onjuiste of onjuiste geheugentoewijzing. De GDB resulteert in de fout wanneer er een onjuiste geheugentoewijzing en -deallocatie optreedt in een C++-programma.
Gezien het vorige codevoorbeeld wordt een “*p”-aanwijzer geïnitialiseerd met een nieuwe int[15]. Deze instructie wijst dynamisch een array van 15 gehele getallen toe met behulp van de nieuwe operator. De pointervariabele “*p” slaat het geheugenadres van de array op.
In de volgende verklaring stelt “delete[] p;,” dat de toewijzing van het geheugen ongedaan is gemaakt met behulp van de opdracht delete[]. Het commando delete[] maakt de toewijzing van het eerder toegewezen geheugen van de “*p”-aanwijzer ongedaan, wat betekent dat het andere systeemgebruik het eerder toegewezen geheugenblok opnieuw kan toewijzen. Wanneer we proberen de waarde van de variabele “*p” af te drukken met behulp van de instructie “cout”, krijgen we de geheugentoegangsfout zoals te zien in de volgende uitvoer:
Houd er rekening mee dat de exacte foutmelding enigszins kan verschillen, afhankelijk van uw GDB-versie en systeem. Maar de “fout: GDB heeft geen toegang tot het geheugen op de locatie” en de gegeven fout in het vorige fragment zijn hetzelfde. Om deze fout op te lossen, verplaatsen we eenvoudigweg de opdracht delete[] na de instructie “cout”. Zie de gewijzigde code hieronder:
#includeint voornaamst ( ) {
int * P = nieuw int [ vijftien ] ;
voor ( int i = 0 ; i < vijftien ; ++ i ) {
P [ i ] = i * 2 - 5 + 8 ;
soa :: uit << 'P[' << i << '] = ' << P [ i ] << soa :: eindl ;
}
verwijderen [ ] P ;
opbrengst 0 ;
}
Hier kunt u zien dat we de array hebben geïnitialiseerd met waarden die tijdens runtime worden berekend, en dat we alle waarden van de lus afdrukken met behulp van de “for”-lus. Het belangrijkste om hier op te merken is de verschuiving van de delete[]-instructie; het wordt nu aangeroepen nadat alle waarden zijn opgehaald van de array die de geheugentoegangsfout heeft verwijderd. Zie de uiteindelijke uitvoer van de code hieronder:
Conclusie
Concluderend duidt de fout “fout: GDB heeft geen toegang tot geheugen op adres” meestal op geheugengerelateerde problemen in C++-code. In dit artikel worden enkele veelvoorkomende scenario's onderzocht die deze fout veroorzaken, om uit te leggen wanneer en hoe deze kan worden opgelost. Wanneer deze fout in de code optreedt, is het essentieel om deze zorgvuldig te beoordelen door goed te letten op de pointervariabelen, geheugentoewijzingen, arrays en structuren.
Bovendien kunnen functies zoals breekpunten die door GDB worden geleverd, helpen bij het lokaliseren van de fout tijdens het debuggen van het programma. Deze functies kunnen helpen bij het vaststellen van de exacte locatie van geheugengerelateerde fouten. Door deze problemen proactief aan te pakken, kunnen de ontwikkelaars de stabiliteit en betrouwbaarheid van hun C++-applicaties verbeteren.