స్టాటిక్ అర్రేని తిరిగి ఇవ్వడానికి పాయింటర్‌లను ఉపయోగించండి
మేము సాధారణ శ్రేణిని ఉపయోగించినప్పుడు, ఏదో ఒకవిధంగా అసాధారణ ఫలితాలను పొందే అవకాశాలు ఉన్నాయి. దీనిని నివారించడానికి, మేము మా C ++ కోడ్‌లో స్టాటిక్ అర్రేని ఉపయోగిస్తాము. మనం ఉపయోగించిన ఉదాహరణను అర్థం చేసుకుందాం. ఈ ఫంక్షన్‌లో, 5 విలువలతో కూడిన శ్రేణిని మేము ఇక్కడ పేర్కొన్న విధంగా రిటర్న్ రకాన్ని ప్రకటించాము.
Int *ఫంక్షన్ ()
విలువ ఒక పూర్ణాంకం రకం కాబట్టి, దిగువ ఉదాహరణలో పూర్ణాంకంగా ట్యాగ్ చేయబడుతుంది. మేము ఫంక్షన్‌ను పాయింటర్‌గా ప్రవేశపెట్టినందున, ఫంక్షన్ పాయింటర్ రకం అవుతుంది. విలువలను నమోదు చేసిన తర్వాత, శ్రేణి ప్రధాన ప్రోగ్రామ్‌కు తిరిగి వస్తుంది.
ప్రధాన కార్యక్రమంలో, మేము ఒక ఫంక్షన్ కాల్ చేసాము. ఫంక్షన్ నుండి తిరిగి వచ్చే విలువను అంగీకరించడానికి, మేము ఒక పూర్ణాంక వేరియబుల్‌ని ఉపయోగిస్తాము. శ్రేణి తిరిగి వచ్చినప్పుడు, మేము దాని విలువలను సులభంగా యాక్సెస్ చేయవచ్చు. విలువలు మానవీయంగా ముద్రించబడతాయి.
Int*పాయింటర్=ఫంక్షన్();పాయింటర్ యొక్క ఉద్దేశ్యం శ్రేణిలోని ఇండెక్స్ ఒకటిలో ఉన్న అంశాన్ని గుర్తించడం. మరో మాటలో చెప్పాలంటే, ఇది శ్రేణిలోని విలువ చిరునామాను చూపుతుంది. అప్పుడు, మేము పాయింటర్‌ను తిరిగి ఇచ్చే ఫంక్షన్ నమూనాను ఉపయోగిస్తాము.
ఫంక్షన్ ద్వారా తిరిగి వచ్చిన శ్రేణి యొక్క అవుట్‌పుట్‌ను చూడటానికి, మేము Linux విషయంలో ఉబుంటు టెర్మినల్‌కు ప్రాప్యత కలిగి ఉండాలి. లైనక్స్ టెర్మినల్ ద్వారా అవుట్పుట్ అందుబాటులో ఉండటం దీనికి కారణం. లైనక్స్‌లో, ఏదైనా టెక్స్ట్ ఎడిటర్‌లో వ్రాసిన సి ++ కోడ్‌లను అమలు చేయడానికి మాకు కంపైలర్ అవసరం. ఈ సంకలనం G ++ ద్వారా జరుగుతుంది. అవుట్‌పుట్‌ను ఫైల్‌లో నిల్వ చేయడానికి -o ఉపయోగించబడుతుంది. ఇక్కడ, మాకు అవుట్పుట్ ఫైల్ మరియు సోర్స్ కోడ్ ఫైల్ అవసరం. సంకలనం తరువాత, మేము కోడ్‌ను అమలు చేస్తాము:
$g ++ -లేదాఫైల్ 1 ఫైల్ 1. సి$/ఫైల్ 1
అవుట్పుట్ నుండి, ఫంక్షన్‌లో ప్రారంభించిన శ్రేణిని, మాన్యువల్‌గా మరియు పాయింటర్‌ల ద్వారా ప్రారంభించిన స్టాటిక్ అర్రేని ఉపయోగించడం ద్వారా ప్రధాన ఫంక్షన్‌లో ప్రదర్శించడాన్ని మనం చూడవచ్చు.
పాయింటర్‌లను ఉపయోగించి డైనమిక్ కేటాయించిన శ్రేణిని తిరిగి ఇవ్వండి
డైనమిక్ కేటాయింపును ఉపయోగించి శ్రేణులను తిరిగి పొందవచ్చు. క్రొత్త పదాన్ని ఉపయోగించడం ద్వారా శ్రేణులను డైనమిక్‌గా కేటాయించవచ్చు. మేము వాటిని మనమే తొలగించే వరకు వారు అక్కడే ఉంటారు. స్టాటిక్ శ్రేణులు పరిమాణంలో స్థిరంగా ఉంటాయి, అంటే మీరు ప్రారంభ సమయంలో పరిమాణాన్ని అందించాలి. శ్రేణిని సృష్టించిన తర్వాత, రన్ టైమ్‌లో లేదా తరువాత పరిమాణాన్ని పెంచడం కష్టం. కానీ డైనమిక్ శ్రేణి విషయంలో, మనం విలువలను నమోదు చేసినప్పుడు అది విస్తరిస్తుంది కాబట్టి మనకు కావలసినప్పుడు మరిన్ని అంశాలను జోడించవచ్చు. కాబట్టి మేము ఏ పరిమాణాన్ని పేర్కొనాల్సిన అవసరం లేదు.
మేము ఇక్కడ ఉపయోగించిన ఉదాహరణ వైపు కదులుతున్నాము. మేము మునుపటి ఉదాహరణల వలె పాయింటర్‌లతో డైనమిక్ శ్రేణిని ఉపయోగించాము, ఇక్కడ మేము స్టాటిక్ శ్రేణులతో పాయింటర్‌లను ఉపయోగించాము.
Int*ఫంక్షన్()ఫంక్షన్ డిక్లరేషన్ తర్వాత, శ్రేణులు డైనమిక్‌గా ప్రకటించబడతాయి:
Int*అమరిక= కొత్త int [100];డైనమిక్ శ్రేణిని సృష్టించడానికి కొత్త అనే పదం నిరంతరం ఉపయోగించబడుతుంది. మేము విలువలను నమోదు చేయడం ద్వారా శ్రేణిలో కార్యకలాపాలు నిర్వహిస్తాము. ఆ తరువాత, శ్రేణి ప్రధాన ప్రోగ్రామ్‌కు తిరిగి ఇవ్వబడుతుంది:
ఇప్పుడు, ప్రధాన విధిని పరిగణించండి. మేము ఫంక్షన్ కాల్ చేసాము. శ్రేణి తిరిగి ఇవ్వబడినందున, విలువను అంగీకరించడానికి మేము పాయింటర్ పూర్ణాంక రకం వేరియబుల్‌ను జోడిస్తాము.
Int*పాయింటర్=ఫంక్షన్();శ్రేణిలో నిల్వ చేయబడిన విలువలు మానవీయంగా ముద్రించబడతాయి. సంకలనం మరియు అమలు పద్ధతి ద్వారా అవుట్పుట్ పొందబడుతుంది.
స్ట్రక్చర్స్ ఉపయోగించి రిటర్న్ అర్రే
నిర్మాణాలు శ్రేణుల వంటి కంటైనర్లు. కానీ శ్రేణి ఒకే సమయంలో ఒకే రకమైన డేటా విలువను కలిగి ఉంటుంది. మరియు నిర్మాణాల విషయంలో, అవి ఒకటి కంటే ఎక్కువ డేటా రకం విలువను కలిగి ఉంటాయి. మేము నమూనా అనే నిర్మాణాన్ని తీసుకున్నాము. ఇక్కడ, శ్రేణి ప్రకటన ఫంక్షన్‌లకు బదులుగా నిర్మాణాల లోపల ఉంది. రిటర్న్ రకం అనేది నిర్మాణం పేరు. స్ట్రక్చర్ వేరియబుల్ ప్రధాన ప్రోగ్రామ్‌కు తిరిగి ఇవ్వబడుతుంది. నిర్మాణం డిక్లరేషన్ కోసం స్ట్రక్ట్ అనే పదాన్ని ఉపయోగిస్తుంది.
నిర్మాణం నమూనా{
Int arr[100];
};
స్ట్రక్చర్ డిక్లరేషన్ తరువాత, మేము ఒక ఫంక్షన్‌ను ఉపయోగించాము, దీనిలో స్ట్రక్చర్ ఆబ్జెక్ట్ సృష్టించబడుతుంది. నిర్మాణాన్ని యాక్సెస్ చేయడానికి ఈ వస్తువు ఉపయోగించబడుతుంది. ఈ ఫంక్షన్ స్ట్రక్చర్ ఆబ్జెక్ట్‌ను ప్రధాన ఫంక్షన్‌కు తిరిగి ఇస్తుంది, తద్వారా మనం ఈ ఆబ్జెక్ట్ ద్వారా శ్రేణిని ప్రింట్ చేయవచ్చు. వేరియబుల్ వేరియబుల్‌లోని విలువలను పొందుతుంది. ఈ విలువ పూర్ణాంక సంఖ్య, దీనిలో మేము శ్రేణిలో విలువలను నమోదు చేస్తాము. ఈ ఉదాహరణలో వలె, మేము 6 సంఖ్యగా ఎంచుకున్నాము. కాబట్టి, శ్రేణిలో సంఖ్యలు 6 వరకు నమోదు చేయబడతాయి.
నమూనా ఫంక్షన్ నిర్మాణం(intఎన్) 
ఇప్పుడు, ప్రధాన ప్రోగ్రామ్ వైపు వెళ్తున్నప్పుడు, దీని ద్వారా శ్రేణిని యాక్సెస్ చేయడానికి మేము ఒక వస్తువును సృష్టించాము:
నమూనా నమూనా x; 
ఆబ్జెక్ట్ ప్రారంభించిన తర్వాత, శ్రేణిలో సంఖ్యలను నమోదు చేయాలని మేము కోరుకునే వేరియబుల్‌కు ఒక విలువ జోడించబడుతుంది. ఫంక్షన్ కాల్‌లో, మేము పారామీటర్‌లో విలువను పాస్ చేస్తాము:
X=ఫంక్షన్(ఎన్);మేము లూప్‌ను ఉపయోగించడం ద్వారా డిస్‌ప్లేను కలిగి ఉంటాము. ప్రధాన ప్రోగ్రామ్ ప్రారంభంలో ప్రకటించిన వస్తువు ద్వారా విలువలు ప్రదర్శించబడతాయి:
మేము ప్రోగ్రామ్‌లో 6 సంఖ్యలను నమోదు చేసినందున ఫలితంలో 6 విలువలు చూపబడతాయని అవుట్పుట్ సూచిస్తుంది.
Std ఉపయోగించి రిటర్న్ అర్రే
ఫంక్షన్ నుండి శ్రేణిని తిరిగి ఇవ్వడానికి C ++ అనేక పద్ధతులను ఉపయోగిస్తుంది. వాటిలో ఒకటి std :: array ద్వారా. ఇది నిర్మాణం యొక్క టెంప్లేట్. ఈ ఫీచర్ పరిమాణం () మరియు ఖాళీ () అనే మరో రెండు ఫంక్షన్లను కూడా అందిస్తుంది. మొత్తం శ్రేణి ప్రధాన ప్రోగ్రామ్‌కు తిరిగి ఇవ్వబడిందని సూచించే శ్రేణి పేరు తిరిగి ఇవ్వబడింది. ఇక్కడ, మేము హెడర్ ఫైల్ శ్రేణిని జోడిస్తాము. లైబ్రరీతో పాటు, ఇది శ్రేణి యొక్క అన్ని విధులను కలిగి ఉంటుంది.
#చేర్చండి 
మేము మొత్తం శ్రేణిని దాని పేరుతో తిరిగి ఇవ్వవచ్చు కాబట్టి, ఫంక్షన్ డిక్లరేషన్‌లో, మేము శ్రేణిని రిటర్న్ టైప్‌గా ఉపయోగిస్తాము. శ్రేణిలో డేటా నమోదు చేయబడింది. ఆ తరువాత, శ్రేణి ప్రధాన ప్రోగ్రామ్‌కు తిరిగి ఇవ్వబడుతుంది. ప్రధాన ఫంక్షన్ వైపు కదులుతున్నప్పుడు, ఫంక్షన్ అని పిలవబడినప్పుడు అర్రే వేరియబుల్ శ్రేణిని అంగీకరిస్తుంది.
అరె=ఫంక్షన్();మళ్లీ, శ్రేణి విలువలను ప్రదర్శించడానికి లూప్ ఉపయోగించబడుతుంది. దిగువ ప్రదర్శించబడిన చిత్రం నుండి మేము అవుట్‌పుట్‌ను గమనిస్తాము. మేము 10 పరిమాణాలను ఉపయోగించినందున, 0 సంఖ్యలు నమోదు చేయబడతాయి. అందువల్ల, ఇవి ప్రదర్శించబడతాయి:
వెక్టర్ కంటైనర్ ద్వారా శ్రేణిని తిరిగి ఇవ్వండి
ఈ విధానం డైనమిక్‌గా కేటాయించిన శ్రేణి. ఈ సందర్భంలో వలె, శ్రేణి పరిమాణాన్ని పేర్కొనవలసిన అవసరం లేదు. మాకు ఇక్కడ ఏ సైజ్ పరామితి అవసరం లేదు. ఈ ఉదాహరణను ఉపయోగించి, మేము వెక్టర్ యొక్క కార్యాచరణలను కలిగి ఉన్న లైబ్రరీలో వెక్టర్ హెడర్‌ను జోడించాలి.
ఫంక్షన్ వైపు వెళ్లడం, ఇక్కడ రిటర్న్ రకం కూడా ఒక int వెక్టర్ మరియు పారామీటర్‌లో ఆర్గ్యుమెంట్‌గా వెక్టర్ పాయింటర్ కూడా ఉంటుంది. పేరు తాత్కాలిక శ్రేణి ఇక్కడ పరిచయం చేయబడింది:
వెక్టర్<int>మల్టిప్లైఅరేబైటూ(కానిస్టేట్వెక్టర్<int> *అరె)Tmp.push_back () ఫంక్షన్ ఉపయోగించి ఫంక్షన్ శ్రేణిలోని మూలకాలను రెండు గుణిస్తుంది. అప్పుడు, tmp ని తిరిగి ఇవ్వండి. ఫంక్షన్ నుండి శ్రేణి యొక్క విలువలను స్వీయ-రకం వేరియబుల్ అంగీకరిస్తుంది. శ్రేణిలోని అంశాలను కలిగి ఉంటుంది.
వెక్టర్ కంటైనర్ యొక్క పనిని అవుట్పుట్ చూపుతుంది.
ముగింపు
పైన పేర్కొన్న వ్యాసంలో, ఫంక్షన్ నుండి శ్రేణిని తిరిగి ఇచ్చే కార్యాచరణను వివరించడానికి సాధారణంగా ఉపయోగించే ఐదు పద్ధతులను మేము వివరించాము.