సెగ్మెంటేషన్ లోపాలు డీబగ్ చేయడానికి సవాలుగా ఉంటాయి, ఎందుకంటే అవి వివరణాత్మక దోష సందేశాలను అందించకుండా క్రాష్‌లకు దారితీస్తాయి. అయినప్పటికీ, GDB (GNU డీబగ్గర్) వంటి సాధనాలు ప్రోగ్రామ్ యొక్క స్థితిని మరియు లోపం సంభవించిన సమయంలో స్టాక్ ట్రేస్‌ను పరిశీలించడం ద్వారా విభజన లోపం యొక్క మూలాన్ని గుర్తించడంలో సహాయపడతాయి.
సెగ్మెంటేషన్ లోపాలు సాధారణంగా ప్రోగ్రామింగ్ లోపాల వల్ల సంభవిస్తాయని మరియు బగ్‌లుగా పరిగణించబడతాయని గమనించడం ముఖ్యం. సమస్యాత్మక కోడ్‌ని సమీక్షించి, సరిదిద్దడం ద్వారా వాటిని పరిష్కరించాలి. విభజన లోపాల యొక్క సాధారణ కారణాలు:
- శూన్య లేదా ప్రారంభించబడని పాయింటర్‌లను తీసివేయడం
- శ్రేణి పరిమితికి వెలుపల రాయడం లేదా చదవడం
- గతంలో డీలోకేట్ చేయబడిన లేదా విడుదల చేసిన మెమరీని ఉపయోగించడం
- స్టాక్ ఓవర్‌ఫ్లో లేదా స్టాక్ అవినీతి
- ప్రారంభించబడని వేరియబుల్స్ ఉపయోగించడం
మీ కోడ్‌ను జాగ్రత్తగా పరిశీలించడం ద్వారా మరియు GDB వంటి డీబగ్గింగ్ సాధనాలను ఉపయోగించడం ద్వారా, మీరు మీ ప్రోగ్రామ్ సరిగ్గా పనిచేస్తుందని మరియు ఈ లోపాలను ఎదుర్కోకుండా చూసుకోవడం ద్వారా సెగ్మెంటేషన్ లోపాలను గుర్తించి, పరిష్కరించవచ్చు.
GDB డీబగ్గర్
GDB (GNU డీబగ్గర్) అనేది ఒక శక్తివంతమైన డీబగ్గింగ్ సాధనం, ఇది సెగ్మెంటేషన్ లోపాలతో సహా కంపైల్డ్ ప్రోగ్రామ్‌లలోని సమస్యలను గుర్తించడానికి మరియు విశ్లేషించడానికి సహాయపడుతుంది. ఇది ప్రోగ్రామ్ యొక్క స్థితిని పరిశీలించడానికి, బ్రేక్‌పాయింట్‌లను ట్రిగ్గర్ చేయడానికి మరియు ఎగ్జిక్యూషన్ ఫ్లోను గమనించడానికి మిమ్మల్ని అనుమతిస్తుంది.
సెగ్మెంటేషన్ లోపాలను డీబగ్ చేయడానికి GDBని సమర్థవంతంగా ఉపయోగించడానికి, మీరు మీ C++ ప్రోగ్రామ్‌ను ప్రారంభించబడిన డీబగ్గింగ్ చిహ్నాలతో కంపైల్ చేయాలి. ఈ చిహ్నాలు ప్రోగ్రామ్ యొక్క నిర్మాణం, వేరియబుల్స్ మరియు డీబగ్గింగ్ ప్రక్రియలో సహాయపడే విధుల గురించి అదనపు సమాచారాన్ని కలిగి ఉంటాయి.
GDBతో C++లో సెగ్మెంటేషన్ లోపాన్ని కనుగొనడం
సెగ్మెంటేషన్ లోపానికి కారణమయ్యే ఉదాహరణ కోడ్ స్నిప్పెట్ ఇక్కడ ఉంది:
#int ప్రధాన ( ) {
int * ptr = nullptr ;
* ptr = 5 ;
తిరిగి 0 ;
}
ముందుగా కోడ్‌ని వివరిద్దాం. ఆ తర్వాత, మునుపటి కోడ్‌లో సెగ్మెంటేషన్ లోపాన్ని కనుగొనడం గురించి మేము దశల్లో చర్చిస్తాము.
“#include
మెయిన్() ఫంక్షన్ లోపల, పాయింటర్ వేరియబుల్ “ptr” టైప్ int* యొక్క డిక్లరేషన్ ఉంది. “nullptr” విలువ పాయింటర్ యొక్క ఇనిషియలైజేషన్‌గా ఉపయోగించబడుతుంది, ఇది ప్రత్యేక శూన్య పాయింటర్ విలువ, ఇది దేనినీ సూచించదని సూచిస్తుంది. చెల్లుబాటు అయ్యే మెమరీ స్థానం.
కింది పంక్తిలో “*ptr = 5;” అనే శూన్య పాయింటర్ “ptr”తో డెరిఫరెన్స్ ప్రయత్నాలు చేయబడతాయి. ఈ సందర్భంలో, “ptr” “nullptr”కి సెట్ చేయబడినందున, యాక్సెస్ చేయడానికి చెల్లుబాటు అయ్యే మెమరీ స్థానం లేదు.
ఇప్పుడు, సెగ్మెంటేషన్ లోపాన్ని కనుగొనడానికి ప్రోగ్రామ్‌ను కంపైల్ చేయడానికి అనుసరించాల్సిన కొన్ని దశలను మేము చర్చిస్తాము.
దశ 1: డీబగ్గింగ్ చిహ్నాలను ప్రారంభించండి
ప్రారంభించడానికి, ప్రారంభించబడిన డీబగ్గింగ్ చిహ్నాలతో మీ C++ ప్రోగ్రామ్‌ను కంపైల్ చేయాలని నిర్ధారించుకోండి. కంపైలేషన్ సమయంలో ఎక్జిక్యూటబుల్ ఫైల్‌కి డీబగ్గింగ్ సమాచారాన్ని అందించడానికి, “-g” ఫ్లాగ్‌ని ఉపయోగించండి. మేము 'main.cpp' అని పిలువబడే C++ ఫైల్‌ని కలిగి ఉన్న సందర్భాన్ని పరిగణించండి.
$ g++ -గ్రా main.cpp -ఓ ప్రధానదశ 2: GDBని అమలు చేయండి
ప్రోగ్రామ్ డీబగ్గింగ్ చిహ్నాలతో కంపైల్ చేయబడిన తర్వాత, ఎక్జిక్యూటబుల్ ఫైల్‌ను ఆర్గ్యుమెంట్‌గా పాస్ చేయడం ద్వారా GDBని అమలు చేయండి.
$ gdb ప్రధానదశ 3: ప్రోగ్రామ్‌ను ప్రారంభించండి
GDB ప్రాంప్ట్‌లో “రన్” లేదా “r” టైప్ చేయడం ద్వారా ప్రోగ్రామ్‌ను ప్రారంభించండి:
$ ( gdb ) పరుగుమీ ప్రోగ్రామ్ అమలు చేయడం ప్రారంభమవుతుంది.
దశ 4: విభజన లోపాన్ని గుర్తించండి
సెగ్మెంటేషన్ లోపాన్ని ఎదుర్కొనే వరకు ప్రోగ్రామ్ రన్ అవుతూనే ఉంటుంది. ప్రోగ్రామ్ ఆపివేయబడుతుంది మరియు GDB ఒక దోష సందేశాన్ని ఉత్పత్తి చేస్తుంది.
ఉదాహరణకు: శూన్య పాయింటర్ ద్వారా సూచించబడిన మెమరీ స్థానానికి 5 విలువను కేటాయించడానికి ప్రయత్నించినప్పుడు, అది విభజన తప్పుకు దారితీసే మునుపు వివరించిన కోడ్‌ని పరిశీలిద్దాం. సెగ్మెంటేషన్ లోపం సంభవించిన లైన్ వద్ద ప్రోగ్రామ్ వెంటనే ముగుస్తుంది.
GDBతో ఈ ప్రోగ్రామ్‌ని అమలు చేస్తున్నప్పుడు, మీరు ఈ క్రింది వాటికి సమానమైన అవుట్‌పుట్‌ని చూస్తారు:
ఈ అవుట్‌పుట్ “main.cpp” ఫైల్‌లోని 5వ పంక్తిలో ప్రధాన ఫంక్షన్‌లో సెగ్మెంటేషన్ లోపం సంభవించిందని సూచిస్తుంది.
దశ 5: స్టాక్ ట్రేస్‌ను పరిశీలించండి
విభజన లోపంపై మరిన్ని అంతర్దృష్టులను పొందడానికి, మీరు “బ్యాక్‌ట్రేస్” కమాండ్ లేదా “bt”ని ఉపయోగించి స్టాక్ ట్రేస్‌ను పరిశీలించవచ్చు. ఈ ఆదేశం క్రాష్‌కు దారితీసే ఫంక్షన్ కాల్‌ల క్రమాన్ని ప్రదర్శిస్తుంది.
$ ( gdb ) btస్టాక్ ట్రేస్ ప్రదర్శించబడుతుంది, ఇది సెగ్మెంటేషన్ తప్పుకు ముందు పిలువబడే ఫంక్షన్‌లను సూచిస్తుంది:
ఈ అవుట్‌పుట్ 'main.cpp' ఫైల్ యొక్క 5వ పంక్తిలో ప్రధాన ఫంక్షన్‌లో విభజన లోపం సంభవించిందని మాకు తెలియజేస్తుంది.
దశ 6: బ్రేక్‌పాయింట్‌లను సెట్ చేయండి
మరింత పరిశోధించడానికి, ఆ పాయింట్ల వద్ద ప్రోగ్రామ్ యొక్క అమలును నిలిపివేయడానికి మీరు నిర్దిష్ట కోడ్ లైన్‌ల వద్ద బ్రేక్‌పాయింట్‌లను సెట్ చేయవచ్చు. ఇది ప్రోగ్రామ్ యొక్క స్థితి మరియు వేరియబుల్స్‌ను తనిఖీ చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. ఉదాహరణకు, “main.cpp” పంక్తి 5 వద్ద బ్రేక్‌పాయింట్‌ను సెట్ చేయడానికి, ఈ క్రింది విధంగా “బ్రేక్” ఆదేశాన్ని ఉపయోగించండి:
$ ( gdb ) బ్రేక్ main.cpp: 5ఇది “main.cpp” ఫైల్‌లోని 5వ పంక్తి వద్ద బ్రేక్‌పాయింట్‌ను సెట్ చేస్తుంది:
దశ 7: అమలును పునఃప్రారంభించండి
బ్రేక్‌పాయింట్‌లను సెట్ చేసిన తర్వాత, “కొనసాగించు” ఆదేశం లేదా “c”ని ఉపయోగించి ప్రోగ్రామ్ యొక్క అమలును పునఃప్రారంభించండి:
$ ( gdb ) కొనసాగుతుందిబ్రేక్పాయింట్కు చేరుకునే వరకు ప్రోగ్రామ్ రన్ అవుతూనే ఉంటుంది.
దశ 8: వేరియబుల్స్ మరియు కోడ్‌ని తనిఖీ చేయండి
ప్రోగ్రామ్ బ్రేక్‌పాయింట్‌లో ఆగిపోయిన తర్వాత, మీరు వేరియబుల్‌లను పరిశీలించడానికి, కోడ్ ద్వారా దశలవారీగా మరియు సెగ్మెంటేషన్ లోపం యొక్క కారణాన్ని పరిశోధించడానికి వివిధ GDB ఆదేశాలను ఉపయోగించవచ్చు.
దశ 9: GDB నుండి నిష్క్రమించండి
మీరు డీబగ్గింగ్‌ని పూర్తి చేసిన తర్వాత, మీరు “విడిచి” ఆదేశాన్ని ఉపయోగించి GDB నుండి నిష్క్రమించవచ్చు:
$ ( gdb ) విడిచిపెట్టుఇది C++ ప్రోగ్రామ్‌లలో సెగ్మెంటేషన్ లోపాలను కనుగొనడానికి GDBని ఉపయోగించడం యొక్క ప్రాథమిక అవలోకనాన్ని అందిస్తుంది. GDB డీబగ్గింగ్‌లో సహాయపడే మరిన్ని ఫీచర్లు మరియు ఆదేశాలను అందిస్తుంది మరియు మీరు మరింత లోతైన సమాచారం కోసం GDB డాక్యుమెంటేషన్‌ని చూడవచ్చు.
ముగింపు
ఈ కథనం C++లో సెగ్మెంటేషన్ లోపాన్ని కనుగొనడానికి GDB యొక్క వినియోగాన్ని ప్రదర్శిస్తుంది. అనుసరించాల్సిన దశలను మేము మీకు వివరించాము. ఈ దశలు GDBని ఉపయోగించి C++లో సెగ్మెంటేషన్ లోపాన్ని ఎలా కనుగొనాలో సమగ్ర వివరణను అందిస్తాయి. ఈ దశలను అనుసరించడం ద్వారా మరియు GDB యొక్క లక్షణాలను ఉపయోగించడం ద్వారా, మీరు మీ C++ ప్రోగ్రామ్‌లో విభజన లోపం యొక్క మూలాన్ని సమర్థవంతంగా గుర్తించవచ్చు మరియు డీబగ్ చేయవచ్చు.