Men mens du bruker GDB, kan du støte på feilen 'feil: GDB kan ikke få tilgang til minnet på adressen'. Denne feilen kan være forvirrende og gjør det vanskelig å fortsette å feilsøke. Denne artikkelen fokuserer på å identifisere hvorfor denne feilen oppstår og se på noen eksempler på kode som hjelper oss å forstå hvordan vi kan løse denne feilen.
Eksempel 1:
La oss se vårt første kodeeksempel som, ved kjøring, gir en 'GDB kan ikke få tilgang til minne på adresse'-feil. Først ser vi på koden. Deretter vil vi se linje for linje forklaring av det.
#include
ved hjelp av navneområde std ;
int hoved- ( tomrom ) {
int * s ;
cout << * s ;
}
Programmet starter med erklæringen om '#include
Innenfor hovedfunksjonen er '*p'-pekervariabelen erklært. Her initialiseres ikke 'p'-variabelen. Derfor peker den ikke til noen spesifikk minneplassering som er reservert for heltallet. Denne linjen forårsaker en feil som vi vil løse senere. I neste linje prøver vi å skrive ut verdien av '*p'-variabelen ved å bruke 'cout'-setningen.
Siden 'p'-variabelen er en peker av typen heltall, brukes stjernen '*' for å avreferere den. Dette betyr at verdien er på minneplasseringen den peker på. Men fordi 'p'-pekeren ikke ble initialisert og ikke peker til noen spesifikk og gyldig plassering, vil det å referere til pekeren resultere i udefinert oppførsel. Derfor resulterer det i å generere ulike typer feil avhengig av systemet og kompilatoren. Siden vi bruker GDB-kompilatoren til å feilsøke og kjøre dette programmet, vil debuggeren gi følgende feil. Feilen vises i utdatabiten:
Som du kan se i utgangen, kan ikke debuggeren få tilgang til minnet. Dette programmet refererer til en uinitialisert peker, hovedårsaken til denne udefinerte oppførselen. La oss nå se hvordan vi kan løse dette problemet. Riktig kode er gitt i det følgende. Ta en titt på det og vi vil forklare hvordan vi fikser feilen i koden:
#include
ved hjelp av navneområde std ;
int hoved- ( tomrom ) {
int val = 5 ;
int * s = & val ;
cout << 'Verdien er = ' << * s ;
}
Som du kan se, er koden modifisert ved å inkludere 'int val =5;' uttalelse. Denne linjen erklærer en heltallsvariabel kalt 'val' og initialiserer den med verdien '5'. Den neste linjen, 'int *p = &val;', erklærer en '*p'-pekervariabel og initialiseres til å peke på adressen til 'val'-variabelen. Tidligere pekte ikke '*p'-pekeren til noen minneadresse som forårsaket at 'ikke får tilgang til minnet på adressen 0x0'.
For å løse dette problemet blir 'var'-variabelen erklært, initialisert og tilordnet til '*p'-pekeren. Nå peker '*p'-pekeren til adressen til 'val'-variabelen da '&'-operatøren tar adressen til 'val' og tilordner den til 'p'. Igjen, 'cout'-setningen brukes til å skrive ut verdien av '*p'-pekeren. Se følgende utdatabit for å se verdien av 'val' som er tilgjengelig av '*p'-pekeren:
Som du kan se, har feilen blitt løst og verdien av '5' er initialisert siden 'val'-variabelen har blitt skrevet ut ved å kalle '*p'-pekeren valribale.
Eksempel 2:
La oss se på et annet eksempel som forklarer hvordan du imøtekommer feilen 'GDB kan ikke få tilgang til minne på adresse' i C++-kodeprogrammet. Koden er gitt i det følgende for din referanse. Ta en titt:
#includeint hoved- ( ) {
int * s = ny int [ femten ] ;
slette [ ] s ;
std :: cout << s [ 2 ] << std :: endl ;
komme tilbake 0 ;
}
Et av de vanligste scenariene utviklerne møter mens de programmerer med pekere, er feil eller feil minneallokering. GDB resulterer i feilen når en feil minneallokering og deallokering oppstår i et C++-program.
Med tanke på forrige kodeeksempel initialiseres en '*p'-peker med en ny int[15]. Denne setningen tildeler dynamisk en matrise med 15 heltall ved å bruke den nye operatoren. Pekervariabelen '*p' lagrer minneadressen til matrisen.
I den følgende setningen, 'delete[] p;,' sier at minnet har blitt deallokert ved hjelp av delete[] kommandoen. Slett[]-kommandoen deallokerer det tidligere tildelte minnet til '*p'-pekeren, noe som betyr at det andre systemet som bruker kan tildele den tidligere tildelte minneblokken igjen. Når vi prøver å skrive ut verdien av '*p'-variabelen ved å bruke 'cout'-setningen, vil vi få minnetilgangsfeilen som vist i følgende utdata:
Tingene du bør huske på her er at den nøyaktige feilmeldingen kan variere litt avhengig av GDB-versjonen og systemet. Men 'feilen: GDB kan ikke få tilgang til minnet på stedet' og den gitte feilen i forrige kodebit er de samme. For å løse denne feilen, flytter vi ganske enkelt delete[]-kommandoen etter 'cout'-setningen. Se den endrede koden i følgende:
#includeint hoved- ( ) {
int * s = ny int [ femten ] ;
til ( int Jeg = 0 ; Jeg < femten ; ++ Jeg ) {
s [ Jeg ] = Jeg * 2 - 5 + 8 ;
std :: cout << 'p[' << Jeg << '] = ' << s [ Jeg ] << std :: endl ;
}
slette [ ] s ;
komme tilbake 0 ;
}
Her kan du se at vi initialiserte matrisen med verdier som er beregnet ved kjøring, og vi skriver ut alle verdiene til løkken ved å bruke 'for'-løkken. Det viktigste å merke seg her er forskyvningen av delete[]-setningen; det kalles nå etter å ha fått alle verdiene til matrisen som har fjernet minnetilgangsfeilen. Se den endelige utgangen av koden i følgende:
Konklusjon
Avslutningsvis indikerer feilen 'feil: GDB kan ikke få tilgang til minne på adresse' vanligvis minnerelaterte problemer i C++-kode. Denne artikkelen utforsket noen vanlige scenarier som utløser denne feilen for å forklare når og hvordan den kan løses. Når denne feilen oppstår i koden, er det viktig å nøye gjennomgå den ved å følge nøye med på pekervariablene, minneallokeringer, matriser og strukturer.
Dessuten kan funksjoner som bruddpunkter som leveres av GDB hjelpe med å finne feilen mens du feilsøker programmet. Disse funksjonene kan hjelpe med å finne den nøyaktige plasseringen av minnerelaterte feil. Ved å ta opp disse problemene proaktivt, kan utviklerne forbedre stabiliteten og påliteligheten til C++-applikasjonene deres.