ఇక్కడ శ్రేణి పరిమాణం లేదా శ్రేణి పొడవు 6. మరియు కేటాయించాల్సిన మొత్తం శ్రేణి పరిమాణం చూపబడలేదు. వేర్వేరు ఆపరేషన్లను వర్తింపజేయడం ద్వారా వాస్తవ పరిమాణం పొందబడుతుంది. ఈ కార్యకలాపాలు ఈ వ్యాసంలో శ్రేణి పరిమాణాన్ని పొందడానికి ఉపయోగించబడతాయి.
ఉదాహరణ 1
ఈ దృష్టాంతంలో, మేము ప్రారంభం () మరియు ముగింపు () అనే భావనను ఉపయోగిస్తాము. ఈ పద్ధతి ద్వారా, శ్రేణి పరిమాణాన్ని సులభంగా తెలుసుకోవచ్చు. ఇవి ప్రామాణిక గ్రంథాలయాలకు ప్రసిద్ధి చెందిన రెండు గ్రంథాలయాలు. ఈ రెండు విధులు శ్రేణి యొక్క ప్రాథమిక మరియు ముగింపు పాయింట్లను చూపించే ఇటరేటర్‌లను తిరిగి అందిస్తాయి. శీర్షిక నుండి మొదలుపెట్టి, మేము శ్రేణి లైబ్రరీని ఉపయోగిస్తాము. ఇందులో శ్రేణికి సంబంధించిన అన్ని విధులు ఉంటాయి. ప్రధాన ఫంక్షన్‌లో, మేము పూర్ణాంక విలువలను కలిగి ఉన్న శ్రేణిని ప్రారంభించాము.
ఖరీదు<<……….<<ముగింపు(కు)-బిగిబ్(కు)<<
ఇక్కడ మేము శ్రేణి పరిమాణాన్ని పేర్కొనలేదు. కౌట్ తరువాత డిస్‌ప్లే స్టేట్‌మెంట్‌లో, మనకు ముగింపు () మరియు ప్రారంభ () విధులు ఉన్నాయి. ఈ రెండు ఫంక్షన్ల మధ్య అసమానత మనకు శ్రేణి పరిమాణాన్ని చూపుతుంది. ఈ ఫంక్షన్ల పారామితులలో, మేము శ్రేణిని పాస్ చేసాము. ఇలా చేయడం ద్వారా, అసలు పరిమాణం నిర్ణయించబడుతుంది. ఈ ఫంక్షన్ల నుండి ఫలిత విలువ నేరుగా ప్రదర్శించబడుతుంది.
ఇప్పుడు అవుట్‌పుట్ వైపు కదులుతోంది. మేము ఈ ప్రోగ్రామ్‌లను లైనక్స్‌లో అమలు చేయాల్సి ఉంది, కాబట్టి మాకు ఉబుంటు టెర్మినల్ ప్రమేయం అవసరం. మేము C ++ కోడ్‌ని ఉపయోగిస్తున్నందున, మేము కంపైలర్ ద్వారా కోడ్‌ను కంపైల్ చేయాలి. అది G ++ కంపైలర్. కోడ్‌ను కంపైల్ చేసిన తర్వాత, మేము దానిని అమలు చేస్తాము. దిగువ ఆదేశాలు మనం ఉపయోగించిన అవుట్‌పుట్ విధానాన్ని చూపుతాయి.
$ గ్రా++ -కోడ్ 2 కోడ్ 2.c$/కోడ్ 2
మీరు ఇప్పుడు అవుట్‌పుట్ చూడవచ్చు. Std విషయంలో ఇదే విధమైన మరొక ఉదాహరణ దూర ఫంక్షన్. ఈ దూరంలో ప్రారంభ () మరియు ముగింపు () ఫంక్షన్లను ఉపయోగించి లెక్కించబడుతుంది. ఈ ఫంక్షన్లను std తో ఉపయోగించడం ద్వారా ఇది పూర్తవుతుంది.
Int n=గంటలు:: దూరం(గంటలు::ప్రారంభించండి(అరె),గంటలు::ముగింపు(అరె)); 
అవుట్‌పుట్ కౌట్ స్టేట్‌మెంట్‌లో పొందబడుతుంది. రికార్డును చూడటానికి, కోడ్‌ను అమలు చేయడానికి కంపైలర్‌ని మళ్లీ ఉపయోగించండి.
మా కావలసిన అవుట్‌పుట్ పొందినట్లు ఇక్కడ మీరు చూడవచ్చు.
ఉదాహరణ 2
ఈ ఉదాహరణ C ++ కోడ్‌లోని sizeof () ఫంక్షన్ వినియోగానికి సంబంధించినది, ఎందుకంటే ఈ విలువ డేటా యొక్క వాస్తవ పరిమాణాన్ని బైట్ల రూపంలో అందిస్తుంది. ఇంకా, ఇది శ్రేణిని నిల్వ చేయడానికి ఉపయోగించే బైట్ల సంఖ్యను తిరిగి ఇవ్వడంలో కూడా వ్యవహరిస్తుంది. మరో మాటలో చెప్పాలంటే, ఈ ఉదాహరణలో, మొదటి దశ శ్రేణి పరిమాణాన్ని ప్రకటించకుండా ఒక శ్రేణిని ప్రారంభించడం. సైజ్‌ఓఫ్ () ఫంక్షన్ కోసం ఉపయోగించే వాక్యనిర్మాణం:
Int అల్= పరిమాణం(అరె)/పరిమాణం(అరె[0]);అర్రే అనేది శ్రేణి. arr [0] శ్రేణిలోని మూలకాల సూచికను చూపుతుంది.
కాబట్టి ఈ ప్రకటన శ్రేణి పరిమాణం ప్రస్తుతం ఉన్న అన్ని మూలకాల పరిమాణంతో ఒకదానితో ఒకటి విభజించబడిందని సూచిస్తుంది. ఇది పొడవును లెక్కించడంలో సహాయపడుతుంది. ఫంక్షన్ నుండి విలువ తిరిగి పొందడానికి మరియు నిల్వ చేయడానికి మేము ఒక పూర్ణాంక వేరియబుల్‌ను ఉపయోగించాము.
అదే కంపైల్-ఎగ్జిక్యూషన్ పద్ధతి ద్వారా కమాండ్ ప్రాంప్ట్ నుండి మేము ఇక్కడ అవుట్‌పుట్ పొందుతాము.
అవుట్‌పుట్ శ్రేణి పరిమాణాన్ని చూపుతుంది, ఇది దానిలో ఉన్న మూలకాల సంఖ్యను సూచిస్తుంది, ఇది 6.
ఉదాహరణ 3
ఈ ఉదాహరణ పరిమాణం () ఫంక్షన్ వినియోగాన్ని కలిగి ఉంటుంది. ఈ ఫంక్షన్ ప్రామాణిక లైబ్రరీ, STL లో ఉంచబడింది. ప్రధాన కార్యక్రమంలో ప్రారంభ దశ శ్రేణి ప్రకటన. ఇక్కడ శ్రేణి పేరు పరిమాణం మరియు పూర్ణాంక విలువను కూడా కలిగి ఉంటుంది. ఈ పద్ధతి ఫలితాన్ని నేరుగా అవుట్‌పుట్ స్టేట్‌మెంట్‌లో అందిస్తుంది.
ఖరీదు<<….<<అరె.పరిమాణం()<<ఫలితాన్ని పొందడానికి లేదా ఫంక్షన్‌ను యాక్సెస్ చేయడానికి 'arr' శ్రేణి అయినప్పుడు, మాకు సైజ్ ఫంక్షన్‌తో శ్రేణి పేరు అవసరం.
ఫలితాన్ని ప్రదర్శించడానికి, ఫలితాన్ని కంపైల్ చేయడానికి మరియు అమలు చేయడానికి మేము g ++ కంపైలర్‌ని ఉపయోగిస్తాము.
అవుట్‌పుట్ నుండి, ఫలితం శ్రేణి యొక్క వాస్తవ పరిమాణాన్ని చూపించే మా కావలసినది అని మీరు చూడవచ్చు.
ఉదాహరణ 4
వేరియబుల్ విలువ యొక్క చిరునామా/లొకేషన్‌ని పాయింటర్‌లు నిల్వచేసే విధంగా పాయింటర్‌లను ఉపయోగించడం ద్వారా శ్రేణి పరిమాణాన్ని కూడా పొందవచ్చు. ఇప్పుడు దిగువ ఇచ్చిన ఉదాహరణను పరిశీలించండి.
ప్రారంభ దశ ఎప్పటిలాగే శ్రేణిని ప్రారంభించడం. అప్పుడు పాయింటర్ శ్రేణి పరిమాణం కోసం పనిచేస్తుంది.
Int లెన్= *(&అమరిక+ 1)- అమరిక;ఇది పాయింటర్‌గా పనిచేసే ప్రధాన ప్రకటన. * శ్రేణిలోని ఏదైనా మూలకం యొక్క స్థానాన్ని గుర్తించడానికి ఉపయోగించబడుతుంది, అయితే పాయింటర్ ద్వారా పొందిన లొకేషన్ విలువను పొందడానికి & ఆపరేటర్ ఉపయోగించబడుతుంది. పాయింటర్ల నుండి మేము శ్రేణి పరిమాణాన్ని పొందడం ఇదే మార్గం. ఫలితం టెర్మినల్ ద్వారా చూపబడుతుంది. సమాధానం ఒకటే. పేర్కొన్న శ్రేణి పరిమాణం 13 గా పేర్కొనబడినందున.
ఉదాహరణ 5
ఈ ఉదాహరణలో, మేము టెంప్లేట్ ఆర్గ్యుమెంట్ తగ్గింపు ఆలోచనను ఉపయోగించాము. టెంప్లేట్ ఆర్గ్యుమెంట్ అనేది ఒక ప్రత్యేక రకమైన పరామితి. ఇది ఒక ఆర్గ్యుమెంట్‌గా పాస్ చేయబడే రెగ్యులర్ ఫంక్షన్ల మాదిరిగానే ఏదైనా రకపు ఆర్గ్యుమెంట్‌ని పాస్ చేయడానికి ఉపయోగించబడుతుంది.
శ్రేణిని పరామితిగా ఆమోదించినప్పుడు, చిరునామాను చూపించడానికి అది పాయింటర్‌గా మార్చబడుతుంది. నిర్దిష్ట శ్రేణి యొక్క పొడవును పొందడానికి, మేము టెంప్లేట్ ఆర్గ్యుమెంట్ మినహాయింపు యొక్క ఈ విధానాన్ని ఉపయోగిస్తాము. Std అనేది ప్రమాణం యొక్క సంక్షిప్త రూపం.
ఇచ్చిన ఉదాహరణను పరిశీలిస్తే, శ్రేణి పరిమాణాన్ని పొందడానికి ఉపయోగించే టెంప్లేట్ క్లాస్‌ని మేము ప్రవేశపెట్టాము. ఇది డిఫాల్ట్ అంతర్నిర్మిత తరగతి, ఇది టెంప్లేట్ వాదనల యొక్క అన్ని కార్యాచరణలను కలిగి ఉంటుంది.
Constexpr std: : పరిమాణం_టిపరిమాణం(కానిస్టేట్టి(&అమరిక)[ఎన్])తప్ప{తిరిగిఎన్;
}
ఈ భావనలో ఇది స్థిరమైన పంక్తి. అవుట్‌పుట్ నేరుగా కౌట్ స్టేట్‌మెంట్‌లో పొందబడుతుంది.
అవుట్‌పుట్ నుండి, మేము కోరుకున్న అవుట్‌పుట్ మాకు లభించిందని మీరు చూడవచ్చు: శ్రేణి పరిమాణం.
ఉదాహరణ 6
ప్రోగ్రామ్‌లోని శ్రేణి పరిమాణాన్ని పొందడానికి మేము std :: వెక్టర్‌ను ఉపయోగిస్తాము. ఇది ఒక రకమైన కంటైనర్; దాని ఫంక్షన్ డైనమిక్ శ్రేణులను నిల్వ చేయడం. ఇది వివిధ కార్యకలాపాల కోసం వివిధ పద్ధతులతో పనిచేస్తుంది. ఈ ఉదాహరణను సాధించడానికి, మేము అన్ని వెక్టర్ ఫంక్షన్లను కలిగి ఉన్న వెక్టర్ లైబ్రరీని ఉపయోగించాము. ఇది ప్రోగ్రామ్‌లో ఉపయోగించాల్సిన సిన్, కౌట్, ఎండ్ఎల్ మరియు వెక్టర్ స్టేట్‌మెంట్‌లను కూడా ప్రకటించింది. ప్రోగ్రామ్‌లో మొదట ఒక శ్రేణి ప్రారంభించబడింది. వెక్టర్ పరిమాణం ద్వారా కౌట్ స్టేట్‌మెంట్‌లో అవుట్‌పుట్ ప్రదర్శించబడుతుంది.
ఖరీదు<<వెక్టర్ పరిమాణం: <<int_array.పరిమాణం() <<endl; 
ఇప్పుడు మనం ఉబుంటు టెర్మినల్ నుండి అవుట్‌పుట్ చూస్తాము. శ్రేణి పరిమాణం దానిలోని మూలకాలకు ఖచ్చితమైనది.
ముగింపు
ఈ ట్యుటోరియల్‌లో, శ్రేణి పొడవు లేదా పరిమాణాన్ని పొందడానికి మేము వేరే విధానాన్ని ఉపయోగించాము. కొన్ని అంతర్నిర్మిత విధులు, మరికొన్ని మానవీయంగా ఉపయోగించబడతాయి.