మీరు Valgrind కింద ప్రోగ్రామ్‌ను అమలు చేసినప్పుడు, ఇది ప్రోగ్రామ్ యొక్క ఎక్జిక్యూటబుల్‌ను డైనమిక్‌గా ఇన్‌స్ట్రుమెంట్ చేస్తుంది, ఇది ప్రోగ్రామ్ మెమరీ వినియోగం మరియు అమలు ప్రవర్తనను పర్యవేక్షించడానికి అనుమతిస్తుంది.
C++లో మెమరీ లీక్‌లు
Valgrind ప్రాథమికంగా C మరియు C++ ప్రోగ్రామ్‌ల కోసం రూపొందించబడిందని మరియు ఇతర భాషలతో లేదా అన్ని సందర్భాల్లో సమర్థవంతంగా పని చేయకపోవచ్చునని గమనించడం ముఖ్యం. అదనంగా, Valgrind కింద ప్రోగ్రామ్‌ని అమలు చేయడం దాని అమలును గణనీయంగా నెమ్మదిస్తుంది, కాబట్టి ఇది తరచుగా ఉత్పత్తి పరిసరాలలో కాకుండా అభివృద్ధి మరియు డీబగ్గింగ్ సమయంలో ఉపయోగించబడుతుంది.
డైనమిక్‌గా సృష్టించబడిన మెమరీ సరిగ్గా విడుదల కానప్పుడు, ఇది C/C++లో మెమరీ లీక్‌లకు కారణమవుతుంది, ఇది అందుబాటులో ఉన్న మెమరీ వనరులను నెమ్మదిగా తగ్గిస్తుంది. ఇది అధిక మెమరీ వినియోగం మరియు ప్రోగ్రామ్ యొక్క పనితీరు క్షీణతకు దారితీస్తుంది.
Valgrid సంస్థాపన
Linux సిస్టమ్‌లో Valgrindని ఇన్స్టాల్ చేయడానికి, ఒక టెర్మినల్‌ను తెరిచి, మీ Linux పంపిణీకి ప్రత్యేకమైన ప్యాకేజీ మేనేజర్‌ని ఉపయోగించి మీ ప్యాకేజీ రిపోజిటరీలను నవీకరించండి. కింది ఆదేశం ఉబుంటు మరియు డెబియన్ ఆధారిత సిస్టమ్‌ల కోసం పనిచేస్తుంది:
$ సుడో సముచితమైన నవీకరణ
Valgrindని ఇన్స్టాల్ చేయడానికి ప్యాకేజీ నిర్వాహికిని ఉపయోగించండి. మళ్ళీ, మీ Linux పంపిణీని బట్టి ఆదేశం మారవచ్చు. ఉబుంటు మరియు డెబియన్ ఆధారిత సిస్టమ్‌ల కోసం కింది ఆదేశాన్ని ఉపయోగించండి:
$ సుడో సముచితమైనది ఇన్స్టాల్ ఎన్నికల ద్వారం
ప్రాంప్ట్ చేసినప్పుడు, మీ వినియోగదారు పాస్‌వర్డ్‌ని నమోదు చేసి, 'Enter' నొక్కండి. సాఫ్ట్‌వేర్‌ను ఇన్స్టాల్ చేయడానికి మీ వినియోగదారు ఖాతాకు అడ్మినిస్ట్రేటివ్ అధికారాలు అవసరమని గమనించండి. ప్యాకేజీ మేనేజర్ ఏవైనా అవసరమైన డిపెండెన్సీలతో పాటు Valgrindని డౌన్‌లోడ్ చేసి, ఇన్స్టాల్ చేస్తుంది. ప్రక్రియకు కొన్ని నిమిషాలు పట్టవచ్చు.
ఇన్‌స్టాలేషన్ ప్రక్రియ పూర్తయిన తర్వాత, కింది ఆదేశాన్ని ధృవీకరణ దశగా అమలు చేయడం ద్వారా మీరు Valgrind యొక్క విజయవంతమైన ఇన్‌స్టాలేషన్‌ను నిర్ధారించవచ్చు:
$ ఎన్నికల ద్వారం --సంస్కరణ: Teluguఈ ఆదేశం Valgrind విజయవంతంగా ఇన్స్టాల్ చేయబడితే దాని సంస్కరణ సమాచారాన్ని ప్రదర్శిస్తుంది.
అంతే! Valgrind ఇప్పుడు మీ Linux సిస్టమ్‌లో ఇన్స్టాల్ చేయబడాలి మరియు మెమరీ లీక్‌లు మరియు ఇతర సమస్యల కోసం మీ C/C++ ప్రోగ్రామ్‌లను విశ్లేషించడానికి మరియు డీబగ్ చేయడానికి మీరు దీన్ని ఉపయోగించవచ్చు.
ఉబుంటులో ఫైల్‌ను సృష్టిస్తోంది
ప్రోగ్రామ్‌లో పని చేయడం ప్రారంభించడానికి, మేము మొదట ఉబుంటులో ఫైల్‌ను సృష్టించాలి. ఫైల్ సృష్టి కోసం, మేము నానో టెక్స్ట్ ఎడిటర్‌ని ఉపయోగిస్తాము. కాబట్టి, మేము టెర్మినల్‌పై ఆదేశాన్ని ఈ క్రింది విధంగా వ్రాస్తాము:
$ నానో ఫైల్1ఇక్కడ, నానో అనేది అమలు చేయబడే టెక్స్ట్ ఎడిటర్ పేరు. 'file1' ఆర్గ్యుమెంట్ మీరు నానో టెక్స్ట్ ఎడిటర్‌ని ఉపయోగించి తెరవాలనుకుంటున్న లేదా సృష్టించాలనుకుంటున్న ఫైల్ పేరును సూచిస్తుంది. నానో ఫైల్ ఇప్పటికే ఉన్నట్లయితే ఎడిటింగ్ కోసం తెరుస్తుంది; కాకపోతే, అది సరఫరా చేయబడిన పేరుతో కొత్త ఫైల్‌ను రూపొందిస్తుంది. మన దగ్గర అలాంటి ఫైల్ లేనందున, అది “file1” పేరుతో కొత్త పత్రాన్ని సృష్టిస్తుంది.
మీరు ఆదేశాన్ని అమలు చేసిన తర్వాత, నానో ఎడిటర్ తెరవబడుతుంది, 'file1' ఫైల్ యొక్క కంటెంట్‌ను నమోదు చేయడానికి లేదా సవరించడానికి మీకు ఖాళీ కాన్వాస్‌ను అందిస్తుంది. మీరు ఇప్పటికే ఉన్న కంటెంట్‌ను ఎడిటర్‌లో టైప్ చేయడం లేదా అతికించడం ప్రారంభించవచ్చు.
ఇప్పుడు అన్ని ముందస్తు అవసరాలు సాధించబడ్డాయి, C++ ప్రోగ్రామ్‌లలో మెమరీ లీక్‌లను గుర్తించడానికి Valgrindని ఉపయోగించడానికి మేము కొన్ని ఉదాహరణలను సృష్టిస్తాము.
ఉదాహరణ 1:
మేము అందించే మొదటి ఉదాహరణ C లోని
int ప్రధాన ( )
{
చార్ * a = malloc ( 102 ) ;
తిరిగి 0 ;
}
కోడ్ యొక్క విచ్ఛిన్నం ఇక్కడ ఉంది:
మేము మొదట ప్రామాణిక లైబ్రరీ హెడర్ ఫైల్
Int main() లైన్ ప్రధాన విధిని ప్రకటిస్తుంది. అప్పుడు, చార్ *a = malloc(102); char* (పాయింటర్ నుండి చార్) యొక్క పాయింటర్ వేరియబుల్ “a”ని ప్రకటించింది. ఇది 102 చార్ ఎలిమెంట్స్ (మొత్తం 102 బైట్లు) యొక్క శ్రేణి కోసం మెమరీని డైనమిక్‌గా కేటాయించడానికి “malloc” ఫంక్షన్‌ని ఉపయోగిస్తుంది. మెమరీ కేటాయింపు పరిమాణం, బైట్‌లలో వ్యక్తీకరించబడింది, ఇది malloc ఫంక్షన్‌కు ఇన్‌పుట్‌గా పంపబడుతుంది మరియు ఇది తాజాగా సృష్టించబడిన మెమరీ బ్లాక్‌కు పాయింటర్‌ను అవుట్‌పుట్ చేస్తుంది. char* పాయింటర్ “a” ఈ పాయింటర్ విలువను కేటాయించింది. చివరగా, 'రిటర్న్ 0;' ప్రధాన విధి ముగింపును సూచిస్తుంది.
సంక్షిప్తంగా, ఈ కోడ్ డైనమిక్‌గా మెమరీని 102 చార్ ఎలిమెంట్‌ల శ్రేణికి “malloc” ఉపయోగించి కేటాయిస్తుంది మరియు మెమరీ చిరునామాను పాయింటర్ “a”కి కేటాయిస్తుంది. అయితే, కోడ్ కేటాయించిన మెమరీని ఏ విధంగానూ ఉపయోగించదు లేదా మార్చదు మరియు ఉచితంగా ఉపయోగించి మెమరీని డీలాకేషన్ చేయదు.
మేము ఈ ప్రోగ్రామ్‌ను Valgrind ద్వారా “–leak-check=full” ఎంపికతో అమలు చేసినప్పుడు, ఇది మెమరీ లీక్ చెక్‌ని నిర్వహిస్తుంది మరియు అవుట్‌పుట్ నివేదికను అందిస్తుంది.
Valgrid ద్వారా ఉత్పత్తి చేయబడిన అవుట్‌పుట్ నివేదిక క్రింది విధంగా ఇవ్వబడింది:
ఉదాహరణ 2:
ఈ దృష్టాంతంతో ప్రారంభించడానికి, కమాండ్‌ను వ్రాయడం ద్వారా గతంలో వివరించిన విధంగా నానో టెక్స్ట్ ఎడిటర్‌ని ఉపయోగించి మేము ముందుగా “test2” ఫైల్‌ను సృష్టిస్తాము:
$ నానో పరీక్ష2ఇప్పుడు, Valgrind ఉపయోగించి ఏదైనా మెమరీ లీక్ ఉందో లేదో తనిఖీ చేయడానికి మేము C++ ప్రోగ్రామ్‌ను వ్రాస్తాము:
##
#include
const int a_s = 3000 ;
పూర్ణాంక ప్రధాన ( ) {
int * ia = malloc ( పరిమాణం ( int ) * a_s ) ;
కోసం ( int i = 0 ; i < a_s; i++ ) {
అది [ i ] = నేను;
}
srand ( సమయం ( శూన్య ) ) ;
int rn = ర్యాండ్ ( ) % a_s;
printf ( 'ఇది[%d]: %d \n ' , rn, అది [ rn ] ) ;
తిరిగి 0 ;
}
ప్రోగ్రామ్ ద్వారా వెళ్దాం.
కోడ్ అవసరమైన హెడర్ ఫైల్‌లను కలిగి ఉంటుంది మరియు 3000 విలువతో “a_s” స్థిరమైన వేరియబుల్‌ను నిర్వచిస్తుంది. మెయిన్() ఫంక్షన్ లోపల, int* రకం పాయింటర్ “IA” ప్రకటించబడుతుంది మరియు మెమరీ “malloc”ని ఉపయోగించి డైనమిక్‌గా కేటాయించబడుతుంది. ఫంక్షన్. “sizeof(int) * a_s” వ్యక్తీకరణ పూర్ణాంకాల “a_s” సంఖ్యను నిల్వ చేయడానికి అవసరమైన మొత్తం మెమరీని నిర్ణయిస్తుంది. 'IA' శ్రేణిలోని అన్ని మూలకాలు దాని సంబంధిత సూచిక విలువతో 'ఫర్' లూప్ ద్వారా ప్రారంభించబడతాయి. ఉదాహరణకు, ia[0] 0, ia[1] 1, మరియు మొదలైనవి.
యాదృచ్ఛిక సంఖ్య జనరేటర్ ప్రస్తుత సమయాన్ని ఉపయోగించి 'srand' ఫంక్షన్‌ని ఉపయోగించి సీడ్ చేయబడింది. ప్రోగ్రామ్ అమలు చేయబడిన ప్రతిసారీ యాదృచ్ఛిక పూర్ణాంకాల యొక్క ప్రత్యేకమైన సెట్‌ను ఉత్పత్తి చేస్తుందని ఇది నిర్ధారిస్తుంది. “ర్యాండ్” ఫంక్షన్ యాదృచ్ఛిక సంఖ్యను ఉత్పత్తి చేస్తుంది మరియు “rn” అనేది rand() % a_s ఫలితంతో కేటాయించబడుతుంది. మాడ్యులస్ ఆపరేటర్ “%” యాదృచ్ఛిక సంఖ్య పరిధిని 0 మరియు a_s – 1 మధ్య ఉండేలా పరిమితం చేస్తుంది, ఇది “ia” శ్రేణిలోని చెల్లుబాటు అయ్యే సూచికకు అనుగుణంగా ఉంటుంది.
చివరగా, ప్రోగ్రామ్ 'ia' శ్రేణి యొక్క యాదృచ్ఛికంగా ఎంచుకున్న సూచిక 'rn' వద్ద సంబంధిత సూచికతో పాటుగా విలువను ముద్రించడానికి 'printf' ఫంక్షన్‌ను ఉపయోగిస్తుంది.
మీరు Valgrind ద్వారా ఈ ప్రోగ్రామ్‌ని అమలు చేసినప్పుడు, ఇది క్రింది అవుట్‌పుట్ నివేదికను రూపొందిస్తుంది:
ముగింపు
C++ ప్రోగ్రామ్‌లో మెమరీ లీక్‌లను గుర్తించడానికి Valgrind సాధనం యొక్క వినియోగాన్ని మేము కనుగొన్నాము. Valgrind యొక్క ఇన్‌స్టాలేషన్ గైడ్ ప్రారంభంలో అందించబడింది. ఆ తర్వాత, నానో టెక్స్ట్ ఎడిటర్‌ని ఉపయోగించి ఉబుంటులో ఫైల్‌ను రూపొందించడం గురించి మేము వివరించాము. చివరికి, ఈ ముందస్తు అవసరాలను ఉపయోగించి, వాటిలో మెమరీ లీక్‌లను తనిఖీ చేయడానికి మేము రెండు C++ ఉదాహరణలను అమలు చేసాము. Valgrind ద్వారా రూపొందించబడిన నివేదిక కూడా జోడించబడింది, ఇది అందించిన ఫైల్‌లోని మెమరీ లీక్‌లను చూపుతుంది.