మెమరీ లీక్ ఎప్పుడు జరుగుతుంది?
సాఫ్ట్‌వేర్ మెమరీని కేటాయించిన తర్వాత కానీ దానితో పూర్తయిన తర్వాత దానిని విడుదల చేయనప్పుడు, a ఉంది మెమరీ లీక్ . పాత మెమొరీని కేటాయించి, ఉపయోగించకుండా వదిలివేసేటప్పుడు ప్రోగ్రామ్ కొత్త వేరియబుల్స్ కోసం మరింత ఎక్కువ మెమరీని కేటాయించడం కొనసాగిస్తుందని దీని అర్థం. ఇది ప్రోగ్రామ్ మరింత ఎక్కువ మెమరీని ఉపయోగిస్తుంది మరియు చివరికి, మెమరీలో లేని లోపం కారణంగా ప్రోగ్రామ్ క్రాష్ అవుతుంది.
C లో మెమరీ లీక్ యొక్క ప్రభావాలు
మెమరీ లీక్ అవుతుంది ప్రోగ్రామ్‌లో చాలా సమస్యలను కలిగిస్తుంది. తనిఖీ చేయకుండా వదిలేస్తే, a మెమరీ లీక్ ప్రోగ్రామ్ క్రాష్ అవ్వడానికి లేదా రన్నింగ్ ఆపివేయడానికి కారణం కావచ్చు, ఇది డేటా నష్టానికి లేదా అవినీతికి దారితీయవచ్చు. అంతేకాకుండా, ప్రోగ్రామ్ అవసరమైన దానికంటే ఎక్కువ మెమరీని వినియోగిస్తున్నందున, ఇది సిస్టమ్ పనితీరును ప్రభావితం చేస్తుంది మరియు అదే సిస్టమ్‌లో నడుస్తున్న ఇతర ప్రోగ్రామ్‌లను నెమ్మదిస్తుంది.
సి లాంగ్వేజ్‌లో మెమరీ కేటాయింపు
మెమరీ కేటాయింపును ఉపయోగించి నిర్వహిస్తారు malloc() C లాంగ్వేజ్‌లో ఫంక్షన్. ఈ పద్ధతి పేర్కొన్న పరిమాణంతో మెమరీ బ్లాక్‌కు సూచనను తిరిగి ఇస్తుంది. కేటాయించిన మెమరీ బ్లాక్‌ను యాక్సెస్ చేయడానికి పాయింటర్ విలువ ఉపయోగించబడుతుంది. ఒకసారి మెమరీ అవసరం లేనప్పుడు, దాన్ని ఉపయోగించి దాన్ని విడిపించాలి ఉచిత() ఫంక్షన్.
మెమరీ లీక్‌ల కారణాలు
యొక్క కొన్ని కారణాలు మెమరీ లీక్‌లు ఉన్నాయి:
1: సరికాని మెమరీ నిర్వహణ
మెమరీ లీక్‌లకు చాలా తరచుగా కారణం ప్రోగ్రామర్ యొక్క పేలవమైన మెమరీ నిర్వహణ. ఇకపై అవసరం లేని మెమరీని విడుదల చేయడాన్ని ప్రోగ్రామ్ నిర్లక్ష్యం చేసినప్పుడు ఇది జరుగుతుంది.
#include
#include
int ప్రధాన ( )
{
int * ptr = ( int * ) malloc ( పరిమాణం ( int ) ) ;
* ptr = 10 ;
printf ( '%d \n ' , * ptr ) ;
ptr = శూన్య ;
తిరిగి 0 ;
}
పై కోడ్‌లో, ఉపయోగించి malloc() లో పద్ధతి ptr పాయింటర్, మేము పూర్ణాంక మెమరీ బ్లాక్ కోసం స్థలాన్ని కేటాయించాము. ది ptr మేము సెట్ చేసినప్పుడు పాయింటర్ విలువ మారుతుంది శూన్య దానికి, ఇంకా అది గతంలో సూచించిన మెమరీ బ్లాక్ విడుదల కాలేదు. కాబట్టి, ఎ మెమరీ లీక్ ఫలితం ఉంటుంది.
అవుట్‌పుట్
2: స్కోప్ పాయింటర్ ముగిసింది
పాయింటర్ వేరియబుల్ ఉనికిలో ఉన్నప్పుడు దాని పరిధి, a మెమరీ లీక్ C ప్రోగ్రామ్‌లలో జరుగుతుంది.
#include#include
int ప్రధాన ( )
{
int సంఖ్య1 = 32 , సంఖ్య 2 = 23 ;
{
int * మొత్తం = ( int * ) malloc ( పరిమాణం ( int ) ) ;
* మొత్తం = సంఖ్య1 + సంఖ్య2 ;
printf ( '%d \n ' , * మొత్తం ) ;
}
printf ( '%d \n ' , * మొత్తం ) ;
తిరిగి 0 ;
}
పై సి ప్రోగ్రామ్‌లో, ది ప్రధాన () పూర్ణాంక మెమరీ బ్లాక్‌ను కేటాయించడానికి ఫంక్షన్ స్థానిక పరిధిని ఉపయోగిస్తుంది మొత్తం పాయింటర్ వేరియబుల్. మేము ఉపయోగించుకున్నందున మొత్తం కొత్తగా ఏర్పడిన మెమరీ బ్లాక్‌కు a మరియు b జోడింపును కేటాయించడానికి పాయింటర్, బ్లాక్ స్కోప్ ముగిసిన తర్వాత కూడా మెమరీ బ్లాక్ నిరంతరం కేటాయించబడుతుంది. కాబట్టి, ఎ మెమరీ లీక్ సంభవిస్తుంది.
అవుట్‌పుట్
C లో మెమరీ లీక్‌లను గుర్తించడం
యొక్క గుర్తింపు మరియు నివారణ మెమరీ లీక్‌లు ప్రోగ్రామ్ స్థిరత్వం మరియు పనితీరును నిర్వహించడానికి కీలకం. కనుగొనుటకు మెమరీ లీక్‌లు , ప్రోగ్రామర్లు వంటి సాధనాలను ఉపయోగించవచ్చు ఎన్నికల ద్వారం , మెమరీ డీబగ్గింగ్ మరియు ప్రొఫైలింగ్ సాధనం. ఎన్నికల ద్వారం ప్రోగ్రామ్‌లోని అన్ని మెమరీ యాక్సెస్‌లను ట్రాక్ చేయడం ద్వారా మెమరీ లీక్‌లను గుర్తించడంలో సహాయపడుతుంది మరియు కేటాయించిన మెమరీ విడుదల కానప్పుడు గుర్తించడంలో సహాయపడుతుంది.
C లో మెమరీ లీక్‌లను నివారించడం
నిరోధించడానికి మెమరీ లీక్‌లు , క్రింద ఇవ్వబడిన సూచనలను అనుసరించండి.
1: ఎల్లప్పుడూ కేటాయించిన మెమరీని విడుదల చేయండి
మెమరీని ఎల్లప్పుడూ ఉపయోగించి స్పష్టంగా విడుదల చేయాలి ఉచిత() వంటి ఫంక్షన్‌ని ఉపయోగించి డైనమిక్‌గా కేటాయించిన తర్వాత పద్ధతి malloc(), calloc(), లేదా realloc() . ఇలా చేయడం ద్వారా, మెమరీ సిస్టమ్‌కు తిరిగి వచ్చిందని మరియు ఇతర ఉపయోగాలకు అందుబాటులో ఉందని నిర్ధారించబడుతుంది.
2: కేటాయించిన మెమరీని పర్యవేక్షించడం
కేటాయించిన మెమరీని పర్యవేక్షించడం అనేది ఇకపై అవసరం లేనప్పుడు విడుదల చేయబడిందని నిర్ధారించుకోవడం చాలా ముఖ్యం. కేటాయించబడిన ప్రతి మెమరీని ట్రాక్ చేయడం ద్వారా మరియు ఇకపై అవసరం లేనప్పుడు దాన్ని విడుదల చేయడం ద్వారా దీనిని సాధించవచ్చు.
3: పాయింటర్లను ట్రాక్ చేయండి
మెమరీ కేటాయింపు మరియు డీలోకేషన్‌ను స్వయంచాలకంగా నిర్వహించడానికి, మెమరీ లీక్‌లను నిరోధించడానికి పాయింటర్లను ట్రాక్ చేయాలి.
4: స్టాటిక్ అనాలిసిస్ టూల్స్ ఉపయోగించండి
నిర్మాణ సమయంలో, స్టాటిక్ అనాలిసిస్ టూల్స్ సాధ్యమని గుర్తించగలవు మెమరీ లీక్‌లు క్లాంగ్ మరియు GCC వంటి C ప్రోగ్రామ్‌లలో. అప్లికేషన్ రన్ అయ్యే ముందు, ఈ సాధనాలు మెమరీ లీక్‌లను గుర్తించడంలో మరియు దిద్దుబాటు సూచనలను చేయడంలో సహాయపడతాయి.
కింది ఉదాహరణ పై ప్రక్రియను వివరిస్తుంది.
#include#
#
int ప్రధాన ( )
{
int * ptr = ( int * ) malloc ( పరిమాణం ( int ) ) ;
ఉంటే ( ptr == శూన్య ) {
printf ( 'మెమరీ కేటాయింపు లోపం. \n ' ) ;
తిరిగి 1 ;
}
* ptr = 10 ;
printf ( '%d \n ' , * ptr ) ;
ఉచిత ( ptr ) ;
తిరిగి 0 ;
}
ఈ ఎగువ కోడ్ ముందుగా మెమరీ కేటాయింపు విజయవంతమైందో లేదో తనిఖీ చేయడం ద్వారా నిర్ణయిస్తుంది ptr సూచన కాదు శూన్య . కేటాయింపు విఫలమైతే కోడ్ తగిన విధంగా లోపాన్ని నిర్వహించవచ్చు. కేటాయింపు విజయవంతమైతే, కోడ్ మెమరీ బ్లాక్‌కు విలువను ఇస్తుంది 10 మరియు దానిని అవుట్‌పుట్ చేస్తుంది. ఆ తర్వాత, కోడ్ ఉపయోగించి కేటాయించిన మెమరీని విడుదల చేస్తుంది ఉచిత() ఫంక్షన్.
అవుట్‌పుట్
ముగింపు
మెమరీ లీక్ అవుతుంది పనితీరు క్షీణత మరియు క్రాష్‌లతో సహా ప్రోగ్రామ్‌లలో ముఖ్యమైన సమస్యలను కలిగిస్తుంది. జాగ్రత్తగా మెమరీ నిర్వహణ, సరైన పరీక్ష మరియు మెమరీ వినియోగాన్ని పర్యవేక్షించడం ద్వారా ఇటువంటి సమస్యలను గుర్తించవచ్చు మరియు నిరోధించవచ్చు. అలాగే, ప్రోగ్రామర్లు మెమరీ లీక్‌ల సంభావ్యత గురించి తెలుసుకోవాలి మరియు వాటిని నిరోధించడానికి అవసరమైన చర్యలు తీసుకోవాలి.