Men mens du bruger GDB, kan du støde på fejlen 'fejl: GDB kan ikke få adgang til hukommelsen på adressen'. Denne fejl kan være forvirrende og gør det svært at fortsætte med at fejlfinde. Denne artikel er fokuseret på at identificere, hvorfor denne fejl opstår, og se på nogle eksempler på kode, der hjælper os med at forstå, hvordan vi løser denne fejl.
Eksempel 1:
Lad os se vores første kodeeksempel, der ved udførelse giver fejlen 'GDB kan ikke få adgang til hukommelse på adresse'. Først ser vi på koden. Derefter vil vi se linje-for-linje forklaring af det.
#include
ved brug af navneområde std ;
int vigtigste ( ugyldig ) {
int * s ;
cout << * s ;
}
Programmet starter med erklæringen af '#include
Inden for hovedfunktionen er '*p' pointervariablen erklæret. Her initialiseres 'p'-variablen ikke. Derfor peger det ikke på nogen specifik hukommelsesplacering, der er reserveret til hele tallet. Denne linje forårsager en fejl, som vi vil løse senere. I den næste linje forsøger vi at udskrive værdien af '*p'-variablen ved hjælp af 'cout'-sætningen.
Da 'p'-variablen er en pointer af typen heltal, bruges stjernen '*' til at dereference den. Det betyder, at værdien er på den hukommelsesplacering, den peger på. Men fordi 'p'-markøren ikke blev initialiseret og ikke peger på nogen specifik og gyldig placering, vil afreference af markøren resultere i udefineret adfærd. Derfor resulterer det i at generere forskellige slags fejl afhængigt af systemet og compileren. Da vi bruger GDB-kompileren til at debugge og køre dette program, vil debuggeren kaste følgende fejl. Fejlen vises i output-snippet:
Som du kan se i outputtet, kan debuggeren ikke få adgang til hukommelsen. Dette program refererer til en uinitialiseret pointer, hovedårsagen til denne udefinerede adfærd. Lad os nu se, hvordan vi kan løse dette problem. Den korrekte kode er angivet i det følgende. Tag et kig på det, og vi vil forklare, hvordan vi retter fejlen i koden:
#include
ved brug af navneområde std ;
int vigtigste ( ugyldig ) {
int val = 5 ;
int * s = & val ;
cout << 'Værdien er = ' << * s ;
}
Som du kan se, ændres koden ved at inkludere 'int val =5;' udmelding. Denne linje erklærer en heltalsvariabel ved navn 'val' og initialiserer den med en værdi på '5'. Den næste linje, 'int *p = &val;', erklærer en '*p' pointervariabel og initialiseres til at pege på adressen på 'val'-variablen. Tidligere pegede '*p'-markøren ikke på nogen hukommelsesadresse, hvilket forårsagede, at 'kan ikke få adgang til hukommelsen på adressen 0x0'.
For at løse dette problem er 'var'-variablen erklæret, initialiseret og tildelt til '*p'-markøren. Nu peger '*p'-markøren på adressen på 'val'-variablen, da '&'-operatoren tager adressen på 'val' og tildeler den til 'p'. Igen bruges 'cout'-sætningen til at udskrive værdien af '*p'-markøren. Se følgende output-snippet for at se værdien af 'val', der tilgås af '*p'-markøren:
Som du kan se, er fejlen blevet løst, og værdien af '5' initialiseres, da 'val'-variablen er blevet udskrevet ved at kalde '*p'-markøren valribale.
Eksempel 2:
Lad os overveje et andet eksempel, der forklarer, hvordan man imødekommer fejlen 'GDB kan ikke få adgang til hukommelse på adresse' i C++-kodeprogrammet. Koden er givet i det følgende til din reference. Tag et kig:
#includeint vigtigste ( ) {
int * s = ny int [ femten ] ;
slette [ ] s ;
std :: cout << s [ 2 ] << std :: endl ;
Vend tilbage 0 ;
}
Et af de mest almindelige scenarier, som udviklerne støder på, mens de programmerer med pointere, er forkert eller ukorrekt hukommelsesallokering. GDB resulterer i fejlen, når en forkert hukommelsesallokering og -deallokering forekommer i et C++-program.
I betragtning af det forrige kodeeksempel initialiseres en '*p'-pointer med en ny int[15]. Denne sætning tildeler dynamisk en matrix med 15 heltal ved hjælp af den nye operator. '*p' pointervariablen gemmer arrayets hukommelsesadresse.
I den følgende sætning angiver 'delete[] p;,' at hukommelsen er blevet deallokeret ved hjælp af delete[] kommandoen. Kommandoen delete[] deallokerer den tidligere tildelte hukommelse af '*p'-markøren, hvilket betyder, at det andet system, der bruger, kan allokere den tidligere allokerede hukommelsesblok igen. Når vi forsøger at udskrive værdien af '*p'-variablen ved hjælp af 'cout'-sætningen, får vi hukommelsesadgangsfejlen som ses i følgende output:
De ting, du skal huske på her, er, at den nøjagtige fejlmeddelelse kan variere lidt afhængigt af din GDB-version og dit system. Men 'fejlen: GDB kan ikke få adgang til hukommelsen på stedet' og den givne fejl i det forrige uddrag er de samme. For at løse denne fejl skifter vi simpelthen delete[]-kommandoen efter 'cout'-sætningen. Se den ændrede kode i det følgende:
#includeint vigtigste ( ) {
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 ;
Vend tilbage 0 ;
}
Her kan du se, at vi initialiserede arrayet med værdier, der beregnes ved kørselstid, og vi udskriver alle værdierne af løkken ved hjælp af 'for'-løkken. Det vigtigste at bemærke her er forskydningen af delete[]-sætningen; det kaldes nu efter at have fået alle værdierne for det array, som har fjernet hukommelsesadgangsfejlen. Se det endelige output af koden i det følgende:
Konklusion
Som konklusion indikerer fejlen 'fejl: GDB kan ikke få adgang til hukommelse på adresse' normalt hukommelsesrelaterede problemer i C++ kode. Denne artikel undersøgte nogle almindelige scenarier, der udløser denne fejl, for at forklare, hvornår og hvordan den kan løses. Når denne fejl opstår i koden, er det vigtigt at gennemgå den omhyggeligt ved at være meget opmærksom på pointervariabler, hukommelsestildelinger, arrays og strukturer.
Desuden kan funktioner som brudpunkter, der leveres af GDB, hjælpe med at lokalisere fejlen, mens du fejlfinder programmet. Disse funktioner kan hjælpe med at lokalisere den nøjagtige placering af hukommelsesrelaterede fejl. Ved at løse disse problemer proaktivt kan udviklerne forbedre stabiliteten og pålideligheden af deres C++-applikationer.