ఈ వ్యాసంలో, మేము పరిశీలిస్తాము calloc() ఫంక్షన్ మరియు దానిని C++లో ఎలా విజయవంతంగా ఉపయోగించుకోవచ్చు.
కాలోక్() ఫంక్షన్ అంటే ఏమిటి?
ది calloc() ఫంక్షన్ C++ ప్రోగ్రామింగ్‌లో మెమరీ కేటాయింపు ఫంక్షన్. ఇది శ్రేణి లేదా వేరియబుల్స్ సెట్ కోసం మెమరీ బ్లాక్‌ను కేటాయించడానికి ఉపయోగించబడుతుంది. ది calloc() ఫంక్షన్ వంటిది malloc() ఫంక్షన్, ఇది కేటాయించిన మెమరీని ప్రారంభంలో సున్నాలకు సెట్ చేస్తుంది తప్ప. ఇది కేటాయించిన మెమరీ తెలిసిన విలువకు ప్రారంభించబడిందని నిర్ధారిస్తుంది, ఇది శ్రేణులు మరియు నిర్మాణాలతో పని చేస్తున్నప్పుడు ఉపయోగకరంగా ఉంటుంది.
కోసం వాక్యనిర్మాణం calloc() ఫంక్షన్ క్రింది విధంగా ఉంది:
శూన్యం * కాల్లోక్ ( పరిమాణం_t nmemb , పరిమాణం_t పరిమాణం )
ఫంక్షన్ రెండు వాదనలను తీసుకుంటుంది: nmemb మరియు పరిమాణం . ది nmemb ఆర్గ్యుమెంట్ కేటాయించబడిన శ్రేణిలోని మూలకాల సంఖ్యను నిర్దేశిస్తుంది, అయితే పరిమాణం వాదన ప్రతి మూలకం యొక్క పరిమాణాన్ని బైట్‌లలో నిర్దేశిస్తుంది.
అలాగే, మెమరీ కేటాయింపు విజయవంతమైతే, ది calloc() ఫంక్షన్ శూన్య పాయింటర్‌ను అందిస్తుంది, లేకపోతే అది కొత్తగా ఏర్పడిన మెమరీ బ్లాక్ ప్రారంభానికి పాయింటర్‌ను అందిస్తుంది. మెమరీ లీక్‌లను నివారించడానికి, మెమరీని కేటాయించారు calloc() ఉపయోగించి తొలగించాలి ఉచిత() ఒకసారి పద్ధతి ఇక అవసరం లేదు.
C++లో calloc() ఫంక్షన్‌ని ఎలా ఉపయోగించాలి?
ఉపయోగించడానికి calloc() C++లో ఫంక్షన్, క్రింద ఇవ్వబడిన దశలను అనుసరించండి:
దశ 1: కోసం అవసరమైన హెడర్ ఫైల్‌ను చేర్చండి calloc() ఫంక్షన్, ఇది
దశ 2: ఆపై కావలసిన డేటా రకం యొక్క పాయింటర్ వేరియబుల్‌ను ప్రకటించండి.
దశ 3: ఆ తర్వాత ఉపయోగించండి calloc() మెమరీని కేటాయించడానికి మరియు దానిని 0కి ప్రారంభించే ఫంక్షన్.
దశ 4: అవసరమైన విధంగా కేటాయించిన మెమరీని ఉపయోగించండి.
దశ 5: మీరు కేటాయించిన మెమరీని ఉపయోగించి పూర్తి చేసిన తర్వాత, దాన్ని ఉపయోగించి దాన్ని ఖాళీ చేయండి ఉచిత() ఫంక్షన్.
కింది ఉదాహరణ చూపిస్తుంది calloc() C++లో ఫంక్షన్ అమలు.
##
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
int * ptr ;
ptr = ( int * ) కాల్లోక్ ( 6 , పరిమాణం ( int ) ) ;
ఉంటే ( ! ptr ) {
కోట్ << 'మెమరీ కేటాయింపు విఫలమైంది' ;
బయటకి దారి ( 1 ) ;
}
కోట్ << 'విలువలను ప్రారంభించడం...' << endl
<< endl ;
కోసం ( int i = 0 ; i < 6 ; i ++ ) {
ptr [ i ] = i * 3 ;
}
కోట్ << 'ప్రారంభించబడిన విలువలు.' << endl ;
కోసం ( int i = 0 ; i < 6 ; i ++ ) {
కోట్ << * ( ptr + i ) << endl ;
}
ఉచిత ( ptr ) ;
తిరిగి 0 ;
}
పై కోడ్‌లో, పూర్ణాంక పాయింటర్ ptr ముందుగా ప్రకటించబడింది. మెమరీని ఉపయోగించి 6 పూర్ణాంకాల కోసం కేటాయించబడుతుంది calloc(), మెమరీని 0తో ప్రారంభించడంతో. ది పరిమాణం (పూర్ణాంకం) పూర్ణాంకాలను నిల్వ చేయడానికి ఎంత మెమరీ అవసరమో లెక్కించడానికి ఫంక్షన్ ఉపయోగించబడుతుంది. మెమొరీ కేటాయింపు విజయాన్ని నిర్ధారించడానికి లోపాల కోసం తనిఖీ చేయబడుతుంది. లేకపోతే, ప్రోగ్రామ్ ముగుస్తుంది మరియు దోష సందేశం చూపబడుతుంది.
గుణించడం ద్వారా పొందిన సంఖ్యలను ఉపయోగించి కేటాయించిన మెమరీ ప్రారంభించబడుతుంది 'i*3' a ఉపయోగించి కోసం లూప్. కేటాయించిన మెమరీలో ఉంచబడిన విలువలు లూప్ మరియు పాయింటర్ అంకగణితం కోసం సెకను ఉపయోగించి ముద్రించబడతాయి *(ptr + i) . అంతిమంగా, డైనమిక్‌గా కేటాయించబడిన మెమరీని కాల్ చేయడం ద్వారా విడుదల చేయబడుతుంది ఉచిత() ఫంక్షన్, ఇది మెమరీ లీక్‌లను ఆపుతుంది. ప్రోగ్రామ్ విజయవంతంగా అమలు చేయబడిందని సంకేతంగా, అది 0ని అందిస్తుంది.
అవుట్‌పుట్
ముగింపు
C++లో, ది calloc() డైనమిక్‌గా మెమరీని కేటాయించడానికి ఫంక్షన్ ఉపయోగపడుతుంది. ఇది మెమరీని కేటాయించడమే కాకుండా దానిని సున్నాలు కూడా చేస్తుంది, ఇది శ్రేణులు మరియు నిర్మాణాలతో పనిచేసేటప్పుడు ఉపయోగపడుతుంది. ఎలా ఉపయోగించాలో అర్థం చేసుకోవడం calloc() మెమరీ లీక్‌లను నివారించడానికి మరియు ప్రోగ్రామ్ ఎగ్జిక్యూషన్ విజయాన్ని నిర్ధారించడానికి సమర్థవంతంగా కీలకం. డెవలపర్లు సురక్షితంగా ఉపయోగించుకోవచ్చు calloc() ఈ వ్యాసంలో ఇచ్చిన సూచనలను అనుసరించడం ద్వారా వారి C++ ప్రోగ్రామ్‌లలో పద్ధతి.