C ++ లో డైనమిక్ మెమరీ కేటాయింపు నిజ సమయ వనరుల అవసరాన్ని పరిష్కరించడానికి మీ అవసరాలను పరిగణలోకి తీసుకునేలా చేస్తుంది. ఈ వ్యాసంలో మేము అన్వేషిస్తాము వివరంగా అన్వేషణ. ఈ వ్యాసంలో క్రింది గమనికలు కవర్ చేయబడతాయి,
- డైనమిక్ మెమరీ కేటాయింపు అవసరమా?
- ఉపయోగించి మెమరీ కేటాయింపు క్రొత్తది కీవర్డ్
- ఉపయోగించి మెమరీని డీలోకేషన్ తొలగించండి కీవర్డ్
- డైనమిక్‌గా కేటాయింపు శ్రేణులు
- వస్తువుల కోసం డైనమిక్ మెమరీ కేటాయింపు
కాబట్టి సి ++ లోని డైనమిక్ మెమరీ కేటాయింపుపై ఈ కథనంతో ప్రారంభిద్దాం
డైనమిక్ మెమరీ కేటాయింపు అవసరమా?
ఒక వాక్యాన్ని అక్షరాల శ్రేణిగా ఇన్పుట్ చేయాలనుకుంటున్నాము, కానీ శ్రేణిలో అవసరమైన అక్షరాల సంఖ్య గురించి మాకు ఖచ్చితంగా తెలియదు.
ఇప్పుడు, అక్షర శ్రేణిని ప్రకటించేటప్పుడు, దాని పరిమాణాన్ని కావలసిన స్ట్రింగ్ పరిమాణం కంటే తక్కువగా పేర్కొంటే, మనకు లోపం వస్తుంది ఎందుకంటే ఇన్పుట్ స్ట్రింగ్ యొక్క పరిమాణంతో పోలిస్తే శ్రేణికి కేటాయించిన మెమరీలో స్థలం తక్కువగా ఉంటుంది. మేము దాని పరిమాణాన్ని ఇన్పుట్ స్ట్రింగ్ పరిమాణం కంటే పెద్దదిగా పేర్కొంటే, అప్పుడు అర్రే మెమరీలో ఒక స్థలాన్ని కేటాయించబడుతుంది, ఇది కావలసిన స్ట్రింగ్ పరిమాణం కంటే చాలా పెద్దది, తద్వారా అనవసరంగా ఎక్కువ మెమరీని అవసరం లేనప్పుడు కూడా వినియోగిస్తుంది.
పై సందర్భంలో, కంపైల్ సమయం వరకు శ్రేణి యొక్క ఖచ్చితమైన పరిమాణం గురించి మాకు ఆలోచన లేదు (కంప్యూటర్ కోడ్‌ను కంపైల్ చేసినప్పుడు మరియు స్ట్రింగ్ వినియోగదారు ఇన్పుట్ చేసినప్పుడు). అటువంటి సందర్భాలలో, మేము ఉపయోగిస్తాము క్రొత్తది ఆపరేటర్.
సి ++ రెండు అనారి ఆపరేటర్లను నిర్వచిస్తుంది క్రొత్తది మరియు తొలగించండి ఇది రన్‌టైమ్‌లో మెమరీని కేటాయించడం మరియు డీలోకేటింగ్ చేసే పనిని చేస్తుంది. ఈ ఆపరేటర్లు (క్రొత్త మరియు తొలగించు) ఉచిత స్టోర్ మెమరీ (హీప్ మెమరీ) పై పనిచేస్తాయి కాబట్టి, వాటిని ఉచిత స్టోర్ ఆపరేటర్ అని కూడా పిలుస్తారు. సి ++ లో డైనమిక్ మెమరీ కేటాయింపు వ్యవస్థకు అవసరమైన మద్దతును పాయింటర్లు అందిస్తాయి.
డైనమిక్ కేటాయింపు సహాయంతో, ఒక ప్రోగ్రామ్ రన్‌టైమ్‌లో మెమరీని పొందవచ్చు.
కంపైల్ సమయంలో గ్లోబల్ మరియు లోకల్ వేరియబుల్స్ మెమరీకి కేటాయించబడతాయి. అయితే, రన్‌టైమ్‌లో మేము గ్లోబల్ లేదా లోకల్ వేరియబుల్స్‌ను జోడించలేము. ప్రోగ్రామ్ వేరియబుల్ మెమరీని ఉపయోగించాల్సిన అవసరం ఉంటే, రన్టైమ్ సమయంలో, అవసరమైనప్పుడు మరియు మెమరీని కేటాయించాల్సి ఉంటుంది. వాస్తవానికి, ఇక్కడ డైనమిక్ కేటాయింపు నిత్యకృత్యాలు ప్రయోజనాన్ని అందిస్తాయి.
స్టాటిక్ మెమరీ కేటాయింపు మరియు డైనమిక్ మెమరీ కేటాయింపుల మధ్య తేడాలు:
ఇది ఏదైనా C ++ ప్రోగ్రామ్ కోసం ఉపయోగించే ప్రాథమిక మెమరీ నిర్మాణం:
మాకు ఇలాంటి చిత్రం అవసరం
జాబితాను క్రమబద్ధీకరించండి c ++
స్టాటిక్ మెమరీ కేటాయింపు కోసం మరియు డైనమిక్ మెమరీ కేటాయింపు కోసం హీప్ ఉపయోగించబడుతుంది, రెండూ కంప్యూటర్ యొక్క RAM లో నిల్వ చేయబడతాయి.
స్టాటిక్ మెమరీ కేటాయింపు నేరుగా మెమరీకి నిల్వ చేయబడినప్పుడు స్టాక్‌లో కేటాయించబడే వేరియబుల్స్ మరియు ఈ మెమరీకి యాక్సెస్ చాలా వేగంగా ఉంటుంది, ప్రోగ్రామ్ కంపైల్ చేసినప్పుడు దాని కేటాయింపు కూడా పరిష్కరించబడుతుంది. ఒక ఫంక్షన్ లేదా ఒక పద్ధతి మరొక ఫంక్షన్‌ను పిలిచినప్పుడు అది మరొక ఫంక్షన్‌ను పిలుస్తుంది మరియు చివరి ఫంక్షన్ దాని విలువను తిరిగి ఇచ్చేవరకు ఈ ఫంక్షన్లన్నింటినీ అమలు చేయడం నిలిపివేయబడుతుంది. స్టాక్ ఎల్లప్పుడూ LIFO (మొదటిది చివరిది) క్రమంలో నిల్వ చేయబడుతుంది, ఇటీవల రిజర్వు చేయబడిన బ్లాక్ ఎల్లప్పుడూ విముక్తి పొందే తదుపరి బ్లాక్. ఇది స్టాక్‌ను ట్రాక్ చేయడానికి సహాయపడుతుంది, స్టాక్ నుండి ఒక బ్లాక్‌ను విడిపించడం అనేది ఒక పాయింటర్‌ను సర్దుబాటు చేయడం కంటే ఎక్కువ కాదు.
కుప్పపై కేటాయించిన వేరియబుల్స్ వారి మెమరీని రన్ టైమ్‌లో కేటాయించగా, డైనమిక్ మెమరీ కేటాయింపు. స్టాక్‌తో పోలిస్తే ఈ మెమరీని యాక్సెస్ చేయడం కొంచెం నెమ్మదిగా ఉంటుంది, అయితే కుప్ప యొక్క పరిమాణం వర్చువల్ మెమరీ పరిమాణంతో మాత్రమే పరిమితం అవుతుంది. కుప్ప యొక్క మూలకం ఒకదానితో ఒకటి ఆధారపడదు మరియు ఏ సమయంలోనైనా యాదృచ్ఛికంగా ప్రాప్యత చేయవచ్చు. మేము ఎప్పుడైనా ఒక బ్లాక్‌ను కేటాయించవచ్చు మరియు ఎప్పుడైనా దాన్ని ఉచితం చేయవచ్చు. కుప్ప యొక్క ఏ భాగాలను ఏ సమయంలో కేటాయించాలో లేదా డీలోకేట్ చేయబడిందో ట్రాక్ చేయడం కష్టమవుతుంది.
సి ++ లోని డైనమిక్ మెమరీ కేటాయింపుపై ఈ కథనంతో కదులుతోంది
ఉపయోగించి మెమరీ కేటాయింపు క్రొత్తది కీవర్డ్
సి ++ లో క్రొత్తది రన్‌టైమ్‌లో మెమరీని కేటాయించడానికి ఆపరేటర్ ఉపయోగించబడుతుంది మరియు మెమరీ బైట్‌లలో కేటాయించబడుతుంది. ది క్రొత్తది హీప్‌లో డైనమిక్ మెమరీ కేటాయింపు కోసం ఒక అభ్యర్థనను ఆపరేటర్ సూచిస్తుంది. తగినంత మెమరీ అందుబాటులో ఉంటే క్రొత్తది ఆపరేటర్ మెమరీని ప్రారంభిస్తుంది మరియు కొత్తగా కేటాయించిన మరియు ప్రారంభించిన మెమరీ యొక్క చిరునామాను పాయింటర్ వేరియబుల్‌కు తిరిగి ఇస్తుంది.
సింటాక్స్:
డేటాటైప్ * పాయింటర్_పేరు = క్రొత్త డేటాటైప్
ఉదాహరణ:
int * ptr = new int // ఈ క్రింది రెండు మార్గాల్లో డైనమిక్ కేటాయింపు అయితే మనం వేరియబుల్ డిక్లేర్ చేయవచ్చు. int * ptr = new int (10) int * ptr = new int {15} // టైప్ డేటా-రకం యొక్క మెమరీ యొక్క బ్లాక్ (శ్రేణి) ను కేటాయించడానికి కొత్త ఆపరేటర్ కూడా ఉపయోగించబడుతుంది. int * ptr = new int [20] // పై స్టేట్మెంట్ 20 పూర్ణాంకాలకు నిరంతరం టైప్ Int యొక్క మెమరీని డైనమిక్‌గా కేటాయిస్తుంది మరియు ఒక పాయింటర్‌ను సీక్వెన్స్ యొక్క మొదటి మూలకానికి ‘ptr’ పాయింటర్‌కు తిరిగి ఇస్తుంది.గమనిక : కుప్పకు కేటాయించడానికి తగినంత మెమరీ లేకపోతే, క్రొత్త అభ్యర్థన మినహాయింపును విసిరి వైఫల్యాన్ని సూచిస్తుంది std :: bad_alloc, కొత్త ఆపరేటర్‌తో “నోథ్రో” ఉపయోగించకపోతే, ఈ సందర్భంలో అది NULL పాయింటర్‌ను అందిస్తుంది. అందువల్ల, ప్రోగ్రామ్‌లో ఉపయోగించే ముందు కొత్తగా ఉత్పత్తి చేయబడిన పాయింటర్ వేరియబుల్ కోసం తనిఖీ చేయడం మంచి పద్ధతి.
సి ++ లోని డైనమిక్ మెమరీ కేటాయింపుపై ఈ కథనంతో కదులుతోంది
ఉపయోగించి మెమరీని డీలోకేషన్ తొలగించండి కీవర్డ్:
కుప్ప మెమరీని ఉపయోగించి వేరియబుల్ లేదా క్లాస్ ఆబ్జెక్ట్‌కు కేటాయించబడుతుంది క్రొత్తది కీవర్డ్, మేము ఆ మెమరీ స్థలాన్ని ఉపయోగించి డీలోకేట్ చేయవచ్చు తొలగించండి కీవర్డ్.
సింటాక్స్:
పాయింటర్_విరియబుల్ తొలగించండి // ఇక్కడ, కొత్తగా సృష్టించిన డేటా ఆబ్జెక్ట్‌కు సూచించే పాయింటర్ పాయింటర్_విరియబుల్. తొలగించు [] pointer_variable // పాయింటర్-వేరియబుల్ చేత సూచించబడిన డైనమిక్‌గా కేటాయించిన శ్రేణి మెమరీని విడిపించడానికి మేము ఈ క్రింది తొలగింపు రూపాన్ని ఉపయోగిస్తాము:
ఉదాహరణ:
ptr తొలగించు [] ptr
గమనిక : ఆబ్జెక్ట్ యొక్క పరిధి లేదా వస్తువు యొక్క జీవితకాలం ప్రోగ్రామ్ అమలు సమయంలో వస్తువు మెమరీలో ఉండిపోయే సమయం. కుప్ప మెమరీ కేటాయింపు స్టాక్ కంటే నెమ్మదిగా ఉంటుంది, ఎందుకంటే, కుప్పలో, మీరు మెమరీని కేటాయించగల ప్రత్యేకమైన క్రమం లేదు, అయితే స్టాక్‌లో ఇది LIFO ను అనుసరిస్తుంది.
సి ++ లోని డైనమిక్ మెమరీ కేటాయింపుపై ఈ కథనంతో కదులుతోంది
ఫైబొనాక్సీ సంఖ్య సి ++
డైనమిక్‌గా కేటాయింపు శ్రేణులు
డైనమిక్ మెమరీ కేటాయింపు అనే భావన యొక్క ప్రధాన ఉపయోగం ఏమిటంటే, ఒక శ్రేణికి మెమరీని కేటాయించడం, దాని పరిమాణాన్ని పేర్కొనడం ద్వారా మనం దానిని ప్రకటించవలసి ఉంటుంది, కానీ దాని గురించి ఖచ్చితంగా తెలియదు.
దాని ఉపయోగాన్ని అర్థం చేసుకోవడానికి ఒక ఉదాహరణ చూద్దాం.
# నేమ్‌స్పేస్‌ను ఉపయోగించి చేర్చండి std int main () {int len, sum = 0 cout<< 'Enter the no. of students in the class' <>len int * mark = new int [len] // డైనమిక్ మెమరీ కేటాయింపు కౌట్<< 'Enter the marks of each student' << endl for( int i = 0 i>* (మార్కులు + i)} (int i = 0 i వివరణ:
ఈ ఉదాహరణలో మొదట మేము వినియోగదారుని ఒక తరగతిలోని విద్యార్థుల సంఖ్యను అడుగుతాము మరియు దాని విలువను లెన్ వేరియబుల్‌లో నిల్వ చేస్తాము. అప్పుడు మేము పూర్ణాంక శ్రేణిని ప్రకటించి, ఈ ప్రకటనను ఉపయోగించి లెన్ వేరియబుల్‌లో నిల్వ చేసిన విలువకు డైనమిక్‌గా సమానమైన మెమరీలో స్థలాన్ని కేటాయిస్తాము int * marks = new int [length] అందువలన ఇది 'పొడవు * (1 పరిమాణం) కు సమానమైన స్థలాన్ని కేటాయించబడుతుంది. పూర్ణ సంఖ్య)'. మిగిలిన కోడ్ స్వీయ వివరణాత్మకమైనది.
సి ++ లోని డైనమిక్ మెమరీ కేటాయింపుపై ఈ కథనంతో కదులుతోంది
వస్తువుల కోసం డైనమిక్ మెమరీ కేటాయింపు
మనం డైనమిక్‌గా వస్తువులను కూడా కేటాయించవచ్చు.
కన్స్ట్రక్టర్ ఒక వస్తువును ప్రారంభించడానికి ఉపయోగించే ఒక ప్రత్యేక తరగతి సభ్యుల ఫంక్షన్ అని మనకు తెలుసు మరియు డిస్ట్రక్టర్ కూడా క్లాస్ మెంబర్ ఫంక్షన్, ఇది వస్తువు పరిధి నుండి బయటకు వెళ్ళినప్పుడల్లా పిలువబడుతుంది.
ఆబ్జెక్ట్‌కు కేటాయించిన మెమరీని విడుదల చేయడానికి డిస్ట్రక్టర్ ఉపయోగపడుతుంది. కింది పరిస్థితులలో దీనిని పిలుస్తారు.
- స్థానిక వస్తువు పరిధికి వెళ్ళినప్పుడు
- గ్లోబల్ ఆబ్జెక్ట్ కోసం, క్లాస్ యొక్క వస్తువుకు పాయింటర్‌కు ఆపరేటర్ వర్తించినప్పుడు
వస్తువులకు మెమరీని డైనమిక్‌గా కేటాయించేటప్పుడు మనం మళ్ళీ పాయింటర్లను ఉపయోగించవచ్చు.
వస్తువుల శ్రేణికి ఉదాహరణ చూద్దాం.
# నేమ్‌స్పేస్‌ను ఉపయోగించడం చేర్చండి రాండమ్ {పబ్లిక్: రాండమ్ () {కౌట్<< 'Constructor' << endl } ~Random() { cout << 'Destructor' << endl } } int main() { Random* a = new Random[3] delete [] a // Delete array return 0 } అవుట్పుట్:
వివరణ:
మేము తరగతి రాండమ్ యొక్క మూడు వస్తువులకు మెమరీని కేటాయిస్తున్నందున కన్స్ట్రక్టర్ మూడుసార్లు పిలువబడతారు. ఈ ప్రతి వస్తువు సమయంలో డిస్ట్రక్టర్‌ను మూడుసార్లు పిలుస్తారు. ‘రాండమ్ * a = క్రొత్త రాండమ్ [3]’ ఈ ప్రకటన మన వస్తువు యొక్క డైనమిక్ మెమరీ కేటాయింపుకు బాధ్యత వహిస్తుంది.
ఈ విధంగా మేము ‘డైనమిక్ మెమరీ కేటాయింపు సి ++’ పై ఈ వ్యాసం ముగింపుకు వచ్చాము. మీరు మరింత తెలుసుకోవాలనుకుంటే, చూడండి విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు కోర్ మరియు అధునాతన జావా భావనలతో పాటు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది.
మాకు ప్రశ్న ఉందా? దయచేసి ఈ బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో దీనిని ప్రస్తావించండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.