అయితే, GDBని ఉపయోగిస్తున్నప్పుడు, మీరు 'ఎర్రర్: GDB అడ్రస్ వద్ద మెమరీని యాక్సెస్ చేయలేరు' అనే లోపాన్ని ఎదుర్కోవచ్చు. ఈ లోపం గందరగోళంగా ఉండవచ్చు మరియు డీబగ్గింగ్‌ను కొనసాగించడాన్ని కష్టతరం చేస్తుంది. ఈ లోపం ఎందుకు సంభవిస్తుందో గుర్తించడం మరియు ఈ లోపాన్ని ఎలా పరిష్కరించాలో అర్థం చేసుకోవడంలో మాకు సహాయపడే కొన్ని కోడ్ ఉదాహరణలను చూడటంపై ఈ కథనం దృష్టి కేంద్రీకరించబడింది.
ఉదాహరణ 1:
అమలు చేసిన తర్వాత, “GDB అడ్రస్ వద్ద మెమరీని యాక్సెస్ చేయదు” ఎర్రర్‌ని ఇచ్చే మా మొదటి కోడ్ ఉదాహరణను చూద్దాం. మొదట, మేము కోడ్ను పరిశీలిస్తాము. అప్పుడు, మేము దాని యొక్క లైన్-బై-లైన్ వివరణను చూస్తాము.
#include
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( శూన్యం ) {
int * p ;
కోట్ << * p ;
}
ప్రోగ్రామ్ “#include
ప్రధాన ఫంక్షన్‌లో, “*p” పాయింటర్ వేరియబుల్ ప్రకటించబడింది. ఇక్కడ, 'p' వేరియబుల్ ప్రారంభించబడలేదు. అందువల్ల, ఇది పూర్ణాంకం కోసం రిజర్వు చేయబడిన నిర్దిష్ట మెమరీ స్థానాన్ని సూచించదు. ఈ లైన్ లోపాన్ని కలిగిస్తుంది, దానిని మేము తర్వాత పరిష్కరిస్తాము. తదుపరి పంక్తిలో, మేము 'కౌట్' స్టేట్‌మెంట్‌ని ఉపయోగించి '*p' వేరియబుల్ విలువను ముద్రించడానికి ప్రయత్నిస్తాము.
'p' వేరియబుల్ టైప్ పూర్ణాంకం యొక్క పాయింటర్ కాబట్టి, దానిని తగ్గించడానికి '*' అనే నక్షత్రం ఉపయోగించబడుతుంది. దీనర్థం విలువ అది సూచించే మెమరీ స్థానంలో ఉంది. అయినప్పటికీ, “p” పాయింటర్ ప్రారంభించబడనందున మరియు ఏదైనా నిర్దిష్ట మరియు చెల్లుబాటు అయ్యే స్థానాన్ని సూచించనందున, పాయింటర్‌ను డిఫెరెన్స్ చేయడం వలన నిర్వచించబడని ప్రవర్తన ఏర్పడుతుంది. అందువల్ల, ఇది సిస్టమ్ మరియు కంపైలర్‌పై ఆధారపడి వివిధ రకాల లోపాలను ఉత్పత్తి చేస్తుంది. ఈ ప్రోగ్రామ్‌ను డీబగ్ చేయడానికి మరియు అమలు చేయడానికి మేము GDB కంపైలర్‌ని ఉపయోగిస్తున్నందున, డీబగ్గర్ క్రింది లోపాన్ని విసురుతుంది. లోపం అవుట్‌పుట్ స్నిప్పెట్‌లో చూపబడింది:
మీరు అవుట్‌పుట్‌లో చూడగలిగినట్లుగా, డీబగ్గర్ మెమరీని యాక్సెస్ చేయదు. ఈ ప్రోగ్రామ్ అసంపూర్తిగా ఉన్న పాయింటర్‌ను విస్మరిస్తుంది, ఈ నిర్వచించబడని ప్రవర్తనకు ప్రధాన కారణం. ఇప్పుడు, మనం ఈ సమస్యను ఎలా పరిష్కరించవచ్చో చూద్దాం. సరైన కోడ్ కింది వాటిలో ఇవ్వబడింది. దాన్ని చూడండి మరియు మేము కోడ్‌లోని బగ్‌ను ఎలా పరిష్కరించాలో వివరిస్తాము:
#include
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( శూన్యం ) {
int విలువ = 5 ;
int * p = & విలువ ;
కోట్ << 'విలువ =' << * p ;
}
మీరు చూడగలిగినట్లుగా, కోడ్ “int val =5;”ని చేర్చడం ద్వారా సవరించబడింది. ప్రకటన. ఈ పంక్తి “val” అనే పూర్ణాంక వేరియబుల్‌ని ప్రకటిస్తుంది మరియు దానిని “5” విలువతో ప్రారంభిస్తుంది. తదుపరి పంక్తి, “int *p = &val;”, “*p” పాయింటర్ వేరియబుల్‌ని ప్రకటిస్తుంది మరియు “val” వేరియబుల్ చిరునామాను సూచించడానికి ప్రారంభించబడింది. మునుపు, '*p' పాయింటర్ ఏ మెమరీ చిరునామాను సూచించలేదు, దీని వలన '0x0 చిరునామా వద్ద మెమరీని యాక్సెస్ చేయలేరు'.
ఈ సమస్యను పరిష్కరించడానికి, “var” వేరియబుల్ ప్రకటించబడింది, ప్రారంభించబడింది మరియు “*p” పాయింటర్‌కు కేటాయించబడుతుంది. ఇప్పుడు, “&” ఆపరేటర్ “val” చిరునామాను తీసుకొని దానిని “p”కి కేటాయించడంతో “*p” పాయింటర్ “val” వేరియబుల్ చిరునామాను చూపుతుంది. మళ్ళీ, '*p' పాయింటర్ విలువను ప్రింట్ చేయడానికి 'కౌట్' స్టేట్‌మెంట్ ఉపయోగించబడుతుంది. “*p” పాయింటర్ ద్వారా యాక్సెస్ చేయబడిన “val” విలువను చూడటానికి క్రింది అవుట్‌పుట్ స్నిప్పెట్‌ను చూడండి:
మీరు గమనించినట్లుగా, '*p' పాయింటర్ valribale కాల్ చేయడం ద్వారా 'val' వేరియబుల్ ముద్రించబడినందున లోపం పరిష్కరించబడింది మరియు '5' విలువ ప్రారంభించబడింది.
ఉదాహరణ 2:
C++ కోడ్ ప్రోగ్రామ్‌లోని “GDB అడ్రస్ వద్ద మెమరీని యాక్సెస్ చేయలేము” లోపాన్ని ఎలా తీర్చాలో వివరించే మరొక ఉదాహరణను పరిశీలిద్దాం. మీ సూచన కోసం కోడ్ క్రింది వాటిలో ఇవ్వబడింది. ఒకసారి చూడు:
#int ప్రధాన ( ) {
int * p = కొత్త int [ పదిహేను ] ;
తొలగించు [ ] p ;
std :: కోట్ << p [ 2 ] << std :: endl ;
తిరిగి 0 ;
}
పాయింటర్లతో ప్రోగ్రామింగ్ చేస్తున్నప్పుడు డెవలపర్లు ఎదుర్కొనే అత్యంత సాధారణ దృశ్యాలలో ఒకటి తప్పు లేదా సరికాని మెమరీ కేటాయింపు. C++ ప్రోగ్రామ్‌లో తప్పు మెమరీ కేటాయింపు మరియు డీలాకేషన్ జరిగినప్పుడు GDB లోపం ఏర్పడుతుంది.
మునుపటి కోడ్ ఉదాహరణను పరిశీలిస్తే, '*p' పాయింటర్ కొత్త పూర్ణాంకంతో ప్రారంభించబడింది[15]. ఈ ప్రకటన కొత్త ఆపరేటర్‌ని ఉపయోగించి 15 పూర్ణాంకాల శ్రేణిని డైనమిక్‌గా కేటాయిస్తుంది. “*p” పాయింటర్ వేరియబుల్ శ్రేణి యొక్క మెమరీ చిరునామాను నిల్వ చేస్తుంది.
కింది స్టేట్‌మెంట్‌లో, “delete[] p;,” డిలీట్[] ఆదేశాన్ని ఉపయోగించి మెమరీ డీలోకేట్ చేయబడిందని పేర్కొంది. డిలీట్[] కమాండ్ '*p' పాయింటర్ యొక్క మునుపు కేటాయించిన మెమరీని డీలోకేట్ చేస్తుంది అంటే ఇతర సిస్టమ్ ఉపయోగించే మునుపు కేటాయించిన మెమరీ బ్లాక్‌ని మళ్లీ కేటాయించవచ్చు. “కౌట్” స్టేట్‌మెంట్‌ని ఉపయోగించి “*p” వేరియబుల్ విలువను ప్రింట్ చేయడానికి ప్రయత్నించినప్పుడు, కింది అవుట్‌పుట్‌లో కనిపించే విధంగా మెమరీ యాక్సెస్ ఎర్రర్‌ను పొందుతాము:
ఇక్కడ గుర్తుంచుకోవలసిన విషయాలు ఏమిటంటే, మీ GDB సంస్కరణ మరియు సిస్టమ్‌పై ఆధారపడి ఖచ్చితమైన దోష సందేశం కొద్దిగా భిన్నంగా ఉండవచ్చు. కానీ 'ఎర్రర్: GDB లొకేషన్ వద్ద మెమరీని యాక్సెస్ చేయదు' మరియు మునుపటి స్నిప్పెట్‌లో ఇచ్చిన ఎర్రర్ ఒకే విధంగా ఉంటాయి. ఈ లోపాన్ని పరిష్కరించడానికి, మేము 'కౌట్' స్టేట్‌మెంట్ తర్వాత డిలీట్[] ఆదేశాన్ని మారుస్తాము. కింది వాటిలో సవరించిన కోడ్ను చూడండి:
#int ప్రధాన ( ) {
int * p = కొత్త int [ పదిహేను ] ;
కోసం ( int i = 0 ; i < పదిహేను ; ++ i ) {
p [ i ] = i * 2 - 5 + 8 ;
std :: కోట్ << 'p[' << i << '] = ' << p [ i ] << std :: endl ;
}
తొలగించు [ ] p ;
తిరిగి 0 ;
}
ఇక్కడ, మేము రన్ సమయంలో లెక్కించబడే విలువలతో శ్రేణిని ప్రారంభించినట్లు మీరు చూడవచ్చు మరియు 'ఫర్' లూప్ ఉపయోగించి లూప్ యొక్క అన్ని విలువలను మేము ప్రింట్ చేస్తాము. డిలీట్[] స్టేట్‌మెంట్‌ని మార్చడం ఇక్కడ గమనించాల్సిన ముఖ్యమైన విషయం; మెమొరీ యాక్సెస్ లోపాన్ని తొలగించిన శ్రేణి యొక్క అన్ని విలువలను పొందిన తర్వాత అది ఇప్పుడు పిలువబడుతుంది. కోడ్ యొక్క తుది అవుట్‌పుట్‌ను క్రింది వాటిలో చూడండి:
ముగింపు
ముగింపులో, “లోపం: GDB చిరునామాలో మెమరీని యాక్సెస్ చేయలేము” లోపం సాధారణంగా C++ కోడ్‌లో మెమరీ సంబంధిత సమస్యలను సూచిస్తుంది. ఈ లోపాన్ని ఎప్పుడు మరియు ఎలా పరిష్కరించవచ్చో వివరించడానికి ఈ వ్యాసం కొన్ని సాధారణ దృశ్యాలను అన్వేషించింది. కోడ్‌లో ఈ లోపం సంభవించినప్పుడు, పాయింటర్ వేరియబుల్స్, మెమరీ కేటాయింపులు, శ్రేణులు మరియు నిర్మాణాలపై చాలా శ్రద్ధ చూపడం ద్వారా దానిని జాగ్రత్తగా సమీక్షించడం చాలా అవసరం.
అంతేకాకుండా, GDB అందించిన బ్రేక్‌పాయింట్‌ల వంటి ఫీచర్‌లు ప్రోగ్రామ్‌ను డీబగ్ చేస్తున్నప్పుడు లోపాన్ని గుర్తించడంలో సహాయపడతాయి. మెమరీ-సంబంధిత లోపాల యొక్క ఖచ్చితమైన స్థానాన్ని గుర్తించడంలో ఈ లక్షణాలు సహాయపడతాయి. ఈ సమస్యలను ముందస్తుగా పరిష్కరించడం ద్వారా, డెవలపర్లు తమ C++ అప్లికేషన్‌ల స్థిరత్వం మరియు విశ్వసనీయతను మెరుగుపరచగలరు.