సి లో మల్లోక్ ఫంక్షన్ ఎలా ఉపయోగించాలి

• ప్రతి పద్ధతికి స్టాక్ మెమరీ స్థానికంగా ఉంటుంది మరియు పద్ధతి తిరిగి వచ్చినప్పుడు, స్టాక్ స్వయంచాలకంగా దాన్ని క్లియర్ చేస్తుంది.
• గ్లోబల్ మెమరీ ఏరియా అన్ని గ్లోబల్ వేరియబుల్స్ కోసం మెమరీని కేటాయిస్తుంది. ప్రోగ్రామ్ ప్రారంభంలో ఈ మెమరీ ప్రాంతం సృష్టించబడుతుంది మరియు చివరికి, ఇది మెమరీ ప్రాంతాన్ని స్వయంచాలకంగా క్లియర్ చేస్తుంది.
• ప్రోగ్రామ్/అప్లికేషన్ యొక్క అన్ని డైనమిక్ అవసరాలను నెరవేర్చడానికి హీప్ మెమరీ ఎల్లప్పుడూ శత్రువు. మేము malloc ఫంక్షన్‌ను ఉపయోగించబోతున్నప్పుడల్లా, అది కుప్ప నుండి కొంత మెమరీని అప్పుగా తీసుకొని దానికి పాయింటర్‌ని ఇస్తుంది.

వాక్యనిర్మాణం:

Malloc యొక్క వాక్యనిర్మాణం (శూన్య**malloc (size_t పరిమాణం). కాబట్టి వాక్యనిర్మాణం malloc కి ఒక పరిమాణం అవసరమని చెబుతుంది, ఇది ప్రాథమికంగా శూన్యమైన పాయింటర్‌ను తిరిగి ఇస్తుంది మరియు పరిమాణం t అనేది సంతకం చేయని పూర్ణాంకంగా నిర్వచించబడింది. మల్లోక్ ఫంక్షన్ కేవలం రాశిలో పేర్కొన్న పరిమాణానికి అనుగుణంగా మెమొరీ బ్లాక్‌ని కేటాయిస్తుంది, ఎందుకంటే సింటాక్స్‌లో సైజు పేర్కొనబడాలి మరియు విజయం సాధించిన తర్వాత, కేటాయించిన మెమరీ యొక్క మొదటి బైట్‌కు సూచించే పాయింటర్‌ను తిరిగి ఇస్తుంది . కాబట్టి, రన్ టైమ్‌లో మెమరీని కేటాయించడం malloc యొక్క పని.

ఎందుకు శూన్యమైన పాయింటర్:

మల్లోకి అది దేనిని సూచిస్తోందనే ఆలోచన లేదు; దీని అర్థం, ఆ మెమరీ స్థానంలో ఏ డేటా నిల్వ చేస్తుందో తెలియదు. ఇది మెమరీ లోపల నిల్వ చేయాల్సిన డేటా రకాన్ని తెలుసుకోకుండా వినియోగదారు కోరిన మెమరీని కేటాయిస్తుంది. అందుకే ఇది శూన్యమైన పాయింటర్‌ను తిరిగి ఇస్తోంది.

Malloc కేవలం మెమరీని కేటాయించిన తర్వాత అది ప్రోగ్రామ్‌లో సరిగ్గా ఉపయోగించబడే విధంగా తగిన రకానికి టైప్‌కాస్ట్ చేయడం వినియోగదారు బాధ్యత. శూన్య పాయింటర్ అనేది ఒక పాయింటర్, ఇది ఏ రకమైన డేటా మల్లోక్ అయినా శూన్య పాయింటర్‌ను అందిస్తుంది, ఎందుకంటే ఆ మెమరీ లోపల ఏ రకమైన డేటా నిల్వ చేయబడుతుందో తెలియదు.

సక్సెస్ మల్లోక్ శూన్యమైన పాయింటర్‌ను ఇస్తే, ఇప్పుడు 6 బైట్‌ల మెమరీని కేటాయించమని ఇక్కడ మేము malloc ని అడుగుతున్నాము. ఆ సందర్భంలో, మేము ఒక పూర్ణాంకం టైప్ పాయింటర్‌కు టైప్‌కాస్ట్ చేయాలి ఎందుకంటే ఆ మెమరీలో ఒక పూర్ణాంకాన్ని నిల్వ చేయాలనుకుంటున్నాము. ఇక్కడ malloc 6 బైట్ల మెమరీని ఒక కుప్పలో కేటాయిస్తుంది మరియు మొదటి బైట్ యొక్క చిరునామా పాయింటర్ ptr లో నిల్వ చేయబడుతుంది.

ఉదాహరణ కార్యక్రమం:

మల్లోక్ భావనను సరైన మార్గంలో అర్థం చేసుకోవడానికి ఇక్కడ ఒక సాధారణ ఉదాహరణ కార్యక్రమం ఉంది.

ఇక్కడ మీరు printf ఫంక్షన్‌తో చూడవచ్చు నేను పూర్ణాంకాల సంఖ్యను నమోదు చేయమని వినియోగదారుని అడుగుతున్నాను. మేము i మరియు n పైన రెండు వేరియబుల్స్ ప్రకటించాము. వేరియబుల్ n అనేది వినియోగదారు నమోదు చేసిన నంబర్‌ను మేము నిల్వ చేసే ప్రదేశం. ఆ తరువాత, మాకు malloc ఫంక్షన్ ఉంది; malloc n పూర్ణాంకాల పరిమాణానికి సమానమైన పరిమాణాన్ని కేటాయించాలని మేము కోరుకుంటున్నాము. N తో int ఉంటే మేము పరిమాణాన్ని గుణిస్తాము; ఇది మనకు n పూర్ణాంకాల పరిమాణాన్ని ఇస్తుంది. ఆ తర్వాత, malloc శూన్యమైన పాయింటర్‌ను తిరిగి ఇస్తుంది, మరియు మేము దానిని పూర్ణాంక పాయింటర్‌కు టైప్‌కాస్ట్ చేస్తున్నాము మరియు మేము చిరునామాను ptr పాయింటర్‌లో నిల్వ చేస్తున్నాము. టైప్‌కాస్టింగ్ ముఖ్యం ఎందుకంటే ఇది మంచి పద్ధతి.

ఇప్పుడు, పాయింటర్‌లో NULL ఉంటే, మెమరీ అందుబాటులో లేదని అర్థం. కాబట్టి మేము ప్రోగ్రామ్ నుండి నిష్క్రమించే వైఫల్య స్థితితో నిష్క్రమించాము. ఇది కాకపోతే, మనం లూప్ కోసం సులభంగా అమలు చేయవచ్చు.

లూప్ 0 నుండి n-1 వరకు నడుస్తుంది, మరియు ప్రతిసారి పూర్ణాంకం ఒక్కొక్కటిగా నమోదు చేయమని మేము వినియోగదారుని అడుగుతాము. స్కాన్ఫ్ ఫంక్షన్‌లో, ptr+i అని వ్రాసిన ఒక విషయం ఉంది, ఎందుకంటే ptr మొదటి బైట్ మెమరీ చిరునామాను కలిగి ఉందని మనకు తెలుసు. చిరునామా ఇక్కడ 1000 అని చెప్పండి, నేను మొదట సున్నాకి సమానం కాబట్టి 1000+0 1000 కాబట్టి ఆ చిరునామాలో మన మొదటి పూర్ణాంకం నిల్వ చేయబడుతుంది, ఆ తర్వాత నేను 1 అయ్యాక 1000+1 అని అంతర్గతంగా అర్థం చేసుకున్న (1000) +1 *4 నేను పూర్ణాంకం యొక్క పరిమాణం 4 బైట్లు అని అనుకుంటే, అది 1004 కి సమానంగా ఉంటుంది, కనుక తదుపరి పూర్ణాంకం 1004 ప్రదేశంలో నిల్వ చేయబడుతుంది. మరియు ఈ విధంగా చిరునామాలు 1000, 1004, 1008 మరియు ఇలా కొనసాగుతాయి. మేము ptr+i కి ముందు ఆంపర్‌స్యాండ్‌ని ఉపయోగించడం లేదు ఎందుకంటే మనం ptr వ్రాసేటప్పుడు ptr ఇప్పటికే చిరునామాను ఇస్తోంది, ఇది కేవలం పాయింటర్, మరియు అది చిరునామాను కలిగి ఉంటుంది, విలువ కాదు, కాబట్టి దాని ముందు ఆంపర్‌స్యాండ్ ఉంచాల్సిన అవసరం లేదు, మరియు ఈ భావన స్పష్టంగా ఉండాలి.

ఇక్కడ ఈ లూప్‌లో, మేము స్క్రీన్‌పై అన్ని పూర్ణాంకాలను ముద్రించే ఒక పనిని చేస్తున్నాము; స్పష్టంగా, మేము ptr+i ని ఉపయోగిస్తున్నాము, కానీ ఇక్కడ, ఈ సందర్భంలో, మేము దానిని డిఫరెన్స్ చేస్తున్నాము ఎందుకంటే ptr+i ఒక చిరునామాను సూచిస్తుంది, కనుక మనం దానిని తగ్గించాల్సిన అవసరం ఉంది. నేను 0 కి సమానమైతే, అది 1000 అవుతుంది, ఎందుకంటే మొదటి చిరునామా 1000 అని మేము ఊహిస్తున్నాము, కాబట్టి మేము దానిని డీరెఫరెన్స్ చేస్తున్నాము; మేము మొదటి పూర్ణాంకాన్ని పొందుతాము, అప్పుడు నేను 1 కి సమానం, మరియు అది 1001 అవుతుంది, కానీ పూర్ణాంకం పరిమాణం 4. మళ్లీ ఉంటే 1004 గా వ్యాఖ్యానించబడుతుంది. మేము దానిని విస్మరిస్తున్నాము, కనుక ఇది మాకు 2 ని ఇస్తుంది^ndపూర్ణ సంఖ్య. ఈ విధంగా, ప్రతిదీ పనిచేస్తుంది.

కాబట్టి, ఇది ప్రాథమికంగా ఒక సాధారణ ప్రోగ్రామ్, ఇది వినియోగదారులను n పూర్ణాంకం నమోదు చేయమని అడుగుతుంది, ఆపై మేము ఆ పూర్ణాంకాలను తెరపై ప్రదర్శిస్తున్నాము. ప్రోగ్రామ్‌ను అమలు చేసిన తర్వాత, ఇది ప్రదర్శించబడుతుంది.

ముందుగా, మేము పూర్ణాంకాల సంఖ్యను నమోదు చేయమని వినియోగదారుని అడుగుతున్నాము, ఆపై వినియోగదారు పూర్ణాంకాలను నమోదు చేస్తున్నారు మరియు మేము వాటిని తెరపై ప్రదర్శిస్తున్నాము.

ముగింపు:

మేము ఇక్కడ చాలా కాలం పాటు కొనసాగిస్తున్నంత వరకు పై ప్రోగ్రామ్‌లో తప్పు లేదు 24 గంటలు వంటి సుదీర్ఘకాలం అమలు చేయడానికి. వారు మళ్లీ malloc ఫంక్షన్‌కు కాల్ చేస్తారు, మరియు మళ్లీ అంటే వారు కుప్ప నుండి జ్ఞాపకశక్తిని అప్పుగా తీసుకుంటూ, తిరిగి రానప్పుడు, ఇది చెడ్డ ప్రోగ్రామింగ్, కాబట్టి తిరిగి వచ్చే ముందు మనం ఉచితంగా (విడుదల చేయాల్సిన మెమరీ చిరునామా) రాయాలి. కాబట్టి malloc ఫ్రీని ఉపయోగించడం ముఖ్యం. కాబట్టి, malloc ని ఉపయోగించి, మేము మెమరీని సంరక్షించాము, మరియు malloc మీరు అడిగినంత పెద్ద మెమరీని కేటాయిస్తుంది.

సంతోషంగా డైనమిక్ మెమరీ కేటాయింపు!