అయితే, డైనమిక్ మెమరీ కేటాయింపులో, ఎగ్జిక్యూషన్ ప్రారంభమైనప్పుడు మెమరీ కేటాయించబడుతుంది. ఈ మెమరీ రన్-టైమ్‌లో ప్రోగ్రామర్ ద్వారా మాన్యువల్‌గా కేటాయించబడుతుంది, దీనిని C++లో రన్-టైమ్ మెమరీ కేటాయింపు అని కూడా పిలుస్తారు. డైనమిక్ మెమరీ పరిమాణాన్ని ప్రోగ్రామ్‌లోని ఏ స్థానంలోనైనా మార్చవచ్చు ఎందుకంటే డిక్లరేషన్ సమయంలో, మేము స్థిరీకరించగల పరిమాణాన్ని పేర్కొనలేదు. మేము నేరుగా వేరియబుల్‌కు విలువను మాత్రమే అందిస్తాము.
సాధారణ వేరియబుల్స్‌కు మెమరీ కేటాయింపులో తేడా
సాధారణ వేరియబుల్స్‌లో, కంపైలర్ ద్వారా కేటాయించబడిన మెమరీ స్వయంచాలకంగా కేటాయించబడుతుంది మరియు డీలోకేట్ చేయబడుతుంది. ప్రోగ్రామర్ ద్వారా మెమరీ డైనమిక్‌గా కేటాయించబడినప్పుడు, సోర్స్ కోడ్ యొక్క తదుపరి అమలులో ఎటువంటి ఉపయోగం లేనప్పుడు అతను మెమరీని తీసివేయాలి లేదా డీలోకేట్ చేయాలి. ఈ పరిస్థితి మెమరీని డీలాకేట్ చేయనప్పుడు ప్రోగ్రామ్ ముగించబడినప్పుడు 'మెమరీ లీక్'కి కారణమవుతుంది.
డైనమిక్ కేటాయింపు కోసం ఆపరేటర్లు
C++లో, మెమరీ కేటాయింపు మరియు డీలాకేషన్‌లో ఇద్దరు ఆపరేటర్లు సహాయం చేస్తారు: మెరుగైన మార్గంలో మెమరీ కేటాయింపు మరియు డీలాకేషన్ కోసం ఉపయోగించే 'కొత్త' మరియు 'తొలగించు'.
కొత్త ఆపరేటర్
ఇది మెమరీ కేటాయింపు కోసం డిమాండ్‌ను సూచిస్తుంది. కొత్త ఆపరేటర్ మెమరీని ప్రారంభిస్తుంది మరియు తగినంత మెమరీ అందుబాటులో ఉంటే కేటాయించిన మెమరీ చిరునామాను పాయింటర్ వేరియబుల్‌కు తిరిగి ఇస్తుంది.
పాయింటర్ వస్తువు = కొత్త సమాచారం - రకం ;
ఆపరేటర్‌ను తొలగించండి
కొత్త ఆపరేటర్ వలె, కేటాయించిన మెమరీని తీసివేయడానికి డిలీట్ ఆపరేటర్ ఉపయోగించబడుతుంది. C++లో, ప్రోగ్రామర్ డీలోకేషన్ కోసం ఈ ఆపరేటర్‌ని ఉపయోగించవచ్చు.
# పాయింటర్_వేరియబుల్‌ని తొలగించండి;
ఉదాహరణ 1
ఈ ఉదాహరణలో, మేము రెండు పాయింటర్లను పరిచయం చేస్తాము: ఒకటి పూర్ణాంకం రకం పాయింటర్ మరియు మరొకటి ఫ్లోట్ పాయింటర్. పాయింటర్లు వాటితో నక్షత్రం గుర్తును ఉపయోగించడం ద్వారా ప్రారంభించబడతాయి.
# Int * pointInt;# ఫ్లోట్ * పాయింట్‌ఫ్లోట్;
ఈ రెండు ప్రింటర్లను ఉపయోగించడం ద్వారా, మేము మెమరీని డైనమిక్‌గా కేటాయిస్తాము.
డైనమిక్ కేటాయింపులో పాయింటర్ల పాత్ర:
నిల్వ స్థలం యొక్క మెమరీ బ్లాక్స్ రూపంలో అభివృద్ధి చేయబడింది. మనం ఒక ప్రోగ్రామ్‌ని ఎగ్జిక్యూట్ చేసినప్పుడల్లా లేదా ఏదైనా ఆపరేషన్ చేసినప్పుడల్లా, మెమరీ ఆ నిర్దిష్ట ప్రయోజనం కోసం కేటాయించబడుతుంది. ఆ మెమరీకి ఒక ప్రత్యేక చిరునామా ఉంది, అది ప్రోగ్రామ్‌తో అనుబంధించబడిన ప్రక్రియను లేదా ప్రోగ్రామ్‌ని ఆ మెమరీకి అనుమతించబడుతుందని గుర్తిస్తుంది. ఏదైనా మెమరీ స్లాట్ అది చెందిన చిరునామా ద్వారా యాక్సెస్ చేయబడుతుంది. కాబట్టి ఈ చిరునామా పాయింటర్ల ద్వారా నిల్వ చేయబడుతుంది. సంక్షిప్తంగా, మెమరీని యాక్సెస్ చేయడానికి మరియు అదే విధంగా, ఏదైనా పనికి మెమరీలో నిర్దిష్ట భాగాన్ని కేటాయించడానికి మనకు పాయింటర్లు అవసరం. చిరునామాలను నిల్వ చేయడానికి పాయింటర్లు అవసరం.
మాన్యువల్ కేటాయింపులో మెమరీ యొక్క డైనమిక్ కేటాయింపు కోసం 'కొత్త' కీవర్డ్ ఉపయోగించబడుతుంది, మెమరీ కంపైలర్ ద్వారా కేటాయించబడుతుంది. రన్ టైమ్‌లో మనం మెమరీని కేటాయించాల్సిన అవసరం లేదు. కానీ డైనమిక్ కేటాయింపు యాదృచ్ఛికంగా ఉన్నందున, మేము పాయింటర్లను గుర్తించాలి మరియు బైండింగ్ ప్రక్రియ కోసం, ఈ కొత్త ఆపరేటర్ ఉపయోగించబడుతుంది.
# పాయింట్ = కొత్త పూర్ణం;అదేవిధంగా, ఫ్లోటింగ్ పాయింటర్ కూడా అలాగే కట్టుబడి ఉంటుంది. బైండింగ్ ప్రక్రియ తర్వాత, మేము ఏదైనా ఆపరేషన్ కోసం బుక్ చేయాలనుకుంటున్న మెమరీకి ఏదైనా విలువను కేటాయిస్తాము. పాయింటర్‌ను ప్రకటించడం ద్వారా, మేము మెమరీకి నిర్దిష్ట విలువను కేటాయిస్తాము.
# *pointInt = 50;పాయింట్ ఫ్లోట్‌ల కోసం ఫ్లోట్ విలువ కూడా ప్రకటించబడుతుంది. కేటాయించిన తర్వాత విలువలను ప్రదర్శించండి.
మేము చర్చించినట్లుగా, 'కొత్త' ఆపరేటర్ కేటాయించడానికి ఉపయోగించబడుతుంది, అయితే 'తొలగించు' మెమరీని డీలోకేట్ చేయడానికి ఉపయోగించబడుతుంది. కాబట్టి మీరు కోడ్‌లో టాస్క్ లేదా ఆపరేషన్ పూర్తి చేసిన తర్వాత, మేము టాస్క్‌కు కేటాయించిన మెమరీని తీసివేస్తాము.
మెమరీలో ఆ భాగాన్ని డీలాకేట్ చేయడం మంచిది, తద్వారా ఏదైనా ఇతర ప్రక్రియ దీన్ని ఉపయోగించుకోవచ్చు. మేము ఈ కేటాయింపును రెండు పాయింటర్లకు వర్తింపజేస్తాము.
పాయింట్‌ని తొలగించండి తేలుతుంది ; 
మీరు టెక్స్ట్ ఎడిటర్‌లో కోడ్‌ను సేవ్ చేసిన తర్వాత, ఉబుంటు టెర్మినల్ మీరు g++ కంపైలర్ ద్వారా ఫైల్ లోపల సోర్స్ కోడ్‌ని అమలు చేయడానికి అనుమతిస్తుంది.
$ g++ -o mem mem.c$ ./mem
అమలు చేసిన తర్వాత, మీరు మెమరీకి కేటాయించిన విలువలను చూస్తారు.
ఉదాహరణ 2
ఈ ఉదాహరణ వినియోగదారు పరస్పర చర్య యొక్క ప్రమేయాన్ని కలిగి ఉంది. మేము వినియోగదారు నుండి విలువను కలిగి ఉండే నంబర్ వేరియబుల్‌ని తీసుకుంటాము. ఈ కార్యక్రమం విద్యార్థుల GPAలో ఫలితాన్ని నిల్వ చేస్తుంది. రన్ టైమ్‌లో అన్ని ఫలితాలు సేవ్ చేయబడతాయి.
వినియోగదారు విద్యార్థుల సంఖ్యను నమోదు చేసినప్పుడు, ప్రతి సంఖ్యకు వ్యతిరేకంగా మెమరీ కేటాయించబడుతుంది. ఫ్లోట్ టైప్ పాయింటర్ ఇక్కడ ప్రారంభించబడింది, అది ఫలితాల మెమరీ కేటాయింపులో ఉపయోగించబడుతుంది.
GPA దశాంశ సంజ్ఞామానంలో ఉన్నందున మేము పాయింటర్‌ను ఫ్లోట్‌లో తీసుకుంటాము. మేము GPA కోసం పాయింటర్ రకం శ్రేణిని తీసుకుంటాము ఎందుకంటే ఇది చాలా మంది విద్యార్థులకు దారి తీస్తుంది.
'కొత్త' కీవర్డ్‌తో ఈ పాయింటర్ శ్రేణి మెమరీతో అమలును బంధిస్తుంది. ప్రతి విద్యార్థికి GPA నమోదు చేయబడుతుంది. వినియోగదారు జోడించాలనుకుంటున్న విద్యార్థుల సంఖ్య మాకు తెలియనందున, మేము నమోదు చేసిన సంఖ్య వరకు GPAని నమోదు చేయడానికి లూప్‌ని ఉపయోగించాము. లూప్ యొక్క ప్రతి పునరావృతంలోనూ, విద్యార్థిని గుర్తించే ఫలితాన్ని నమోదు చేయడానికి వినియోగదారుని విచారిస్తారు. ఫలితం సేవ్ చేయబడిన తర్వాత, విద్యార్థుల యొక్క అన్ని GPAలను ప్రదర్శించడానికి మేము మళ్లీ లూప్‌ని ఉపయోగిస్తాము. చివరికి, డైనమిక్ నిల్వ యొక్క ఉద్దేశ్యం నెరవేరినందున, పాయింటర్ రకం శ్రేణి తొలగించబడుతుంది.
తొలగించు [ ] ptr ;ఇప్పుడు మనం పైన పేర్కొన్న కోడ్‌ని అమలు చేస్తాము. విద్యార్థుల సంఖ్యను నమోదు చేయమని వినియోగదారు ముందుగా అభ్యర్థించబడతారు. అప్పుడు ప్రతి విద్యార్థికి GPA నమోదు చేయబడుతుంది.
ఉదాహరణ 3
ఈ ఉదాహరణ క్లాస్ ఆబ్జెక్ట్ కోసం కొత్త మరియు డిలీట్ ఆపరేటర్‌లను ఉపయోగిస్తుంది. ఈ తరగతి వయస్సును నిల్వ చేసే పూర్ణాంక రకం యొక్క ప్రైవేట్ వేరియబుల్‌ను కలిగి ఉంది. తరగతి పబ్లిక్ పార్ట్‌లో, వయస్సును '10' సంఖ్యకు ప్రారంభించే కన్స్ట్రక్టర్ సృష్టించబడింది. కన్స్ట్రక్టర్‌లో ప్రారంభించబడిన వయస్సును ప్రదర్శించే మరొక ఫంక్షన్ ఇక్కడ ఉపయోగించబడుతుంది.
ఇప్పుడు మేము డైనమిక్ కేటాయింపు కోసం ప్రధాన ప్రోగ్రామ్ వైపు వెళ్తాము. తరగతి వస్తువు డైనమిక్‌గా సృష్టించబడుతుంది.
విద్యార్థి * ptr = కొత్త విద్యార్థి ( ) ; 
వస్తువు ఏర్పడినప్పుడు, కన్స్ట్రక్టర్ స్వయంచాలకంగా అమలు చేయబడుతుంది. వయస్సును పొందడానికి ఒక ఫంక్షన్ కాల్ చేయబడుతుంది. ఇది ptr ద్వారా చేయబడుతుంది.
Ptr - > వయస్సు ( ) ;మరియు ముగింపులో, మెమరీ విడుదల అవుతుంది.
ముగింపు
కంపైలర్ ద్వారా గుర్తించబడిన స్థిర నిల్వకు బదులుగా ప్రోగ్రామర్ ద్వారా రన్ టైమ్ ఎగ్జిక్యూషన్ వద్ద డైనమిక్ మెమరీ కేటాయింపు కేటాయించబడుతుంది. ఈ కేటాయింపు యాదృచ్ఛిక ప్రాతిపదికన ఉంది మరియు దీనిని ఉపయోగించిన తర్వాత తొలగించవచ్చు. అయితే, చాలా సందర్భాలలో, తొలగింపుకు ముందు, అమలు ప్రక్రియ ఆగిపోతుంది మరియు ఈ డైనమిక్ కేటాయింపు మెమరీ లీక్‌లకు కారణమవుతుంది. మేము ఈ దృగ్విషయాన్ని ఉబుంటు లైనక్స్ సిస్టమ్‌లో C++ ప్రోగ్రామింగ్ లాంగ్వేజ్‌ని ఉపయోగించి వివిధ విధానాలలో అమలు చేసాము.