C++లో std::array అంటే ఏమిటి
C++లో, ఒక కంటైనర్ అంటారు std::శ్రేణి ఒకే డేటా రకం ఐటెమ్‌ల యొక్క నిర్ణీత సంఖ్యను కలిగి ఉండేలా ఉపయోగించబడింది. ది std::శ్రేణి కంటైనర్ C-శైలి శ్రేణులకు ప్రత్యామ్నాయాన్ని అందిస్తుంది, ఎందుకంటే ఇది సురక్షితమైనది, ఉపయోగించడానికి సులభమైనది మరియు మెరుగైన పనితీరును కలిగి ఉంటుంది.
C++ యొక్క ప్రామాణిక లైబ్రరీలో ఒక భాగం అయిన క్లాస్, ఒకే డేటా రకంతో ఎలిమెంట్‌లను నిల్వ చేయడానికి మరియు యాక్సెస్ చేయడానికి ఆచరణాత్మక మరియు సమర్థవంతమైన విధానాన్ని అందిస్తుంది. పరిమాణం ఎందుకంటే std::శ్రేణి కంపైల్ సమయంలో తెలుస్తుంది, డైనమిక్ స్కేలింగ్ యొక్క రన్‌టైమ్ ఓవర్‌హెడ్ తగ్గించబడుతుంది. శ్రేణి పరిమాణం టెంప్లేట్ పరామితి మరియు అంశాల ద్వారా సెట్ చేయబడింది std::శ్రేణి స్మృతిలో ఉంచబడతాయి.
C++లో std::arrayని ప్రకటించండి
మీరు ప్రకటించగలరు std::శ్రేణి ఇష్టం:
std :: అమరిక < int , 4 > అరె ;
పై వాక్యనిర్మాణం పేరు పెట్టబడిన శ్రేణిని ప్రకటించింది అరె 4 మూలకాల యొక్క స్థిర పరిమాణంతో, ప్రతి మూలకం పూర్ణాంక రకంగా ఉంటుంది.
std::array యొక్క ఉదాహరణ
ఉదాహరణ 1: కిందిది ప్రారంభ a కి ఒక సాధారణ ఉదాహరణ std::శ్రేణి C++లో:
#
#
int ప్రధాన ( ) {
std :: అమరిక < int , 4 > అరె = { 4 , 6 , 2 , 1 } ;
కోసం ( int i = 0 ; i < అరె. పరిమాణం ( ) ; i ++ ) {
std :: కోట్ << అరె [ i ] << '' ;
}
std :: కోట్ << std :: endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్
ఉదాహరణ 2: మీరు కూడా ఉపయోగించవచ్చు std::శ్రేణి శ్రేణిలోని మూలకాలను యాక్సెస్ చేయడానికి. కోడ్ క్రింద ఇవ్వబడింది:
##
int ప్రధాన ( ) {
std :: అమరిక < int , 3 > అరె = { 1 , 2 , 3 } ;
std :: కోట్ << 'మొదటి మూలకం' << అరె [ 0 ] << std :: endl ;
std :: కోట్ << 'రెండవ మూలకం' << అరె. వద్ద ( 1 ) << std :: endl ;
std :: కోట్ << 'మూడవ అంశం' << అరె. తిరిగి ( ) << std :: endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్
ఉదాహరణ 3: కింది ఉదాహరణ ఉపయోగించి నిర్దిష్ట స్థానం వద్ద శ్రేణి నుండి మూలకాన్ని ముద్రించడాన్ని చూపుతుంది std::శ్రేణి C++లో.
##
int ప్రధాన ( )
{
std :: అమరిక < int , 4 > అరె = { 4 , 6 , 2 , 1 } ;
std :: కోట్ << అరె [ 3 ] << std :: endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్
C++లో std::array యొక్క ప్రయోజనాలు
C++లో సాంప్రదాయ శ్రేణుల వలె కాకుండా, std::శ్రేణి ఫీచర్ల శ్రేణిని అందిస్తుంది.
1: సహజమైన సింటాక్స్
std::శ్రేణి ప్రారంభించడం కోసం మరింత స్పష్టమైన సింటాక్స్‌ను కలిగి ఉంది మరియు ఇనిషియలైజర్ జాబితాను ఉపయోగించి ప్రారంభించవచ్చు. ఇది శ్రేణిని ప్రారంభించేందుకు మరింత సంక్షిప్త మరియు చదవగలిగే మార్గాన్ని అందిస్తుంది.
2: వాదనలుగా ఆమోదించబడింది
std::శ్రేణి ఫంక్షన్‌లకు ఆర్గ్యుమెంట్‌లుగా పంపవచ్చు మరియు ఫంక్షన్‌ల నుండి కూడా వాటిని తిరిగి పొందడం సాధ్యమవుతుంది.
3: మెమరీ నిర్వహణ
ఉపయోగించడం యొక్క ముఖ్య ప్రయోజనాల్లో ఒకటి std::శ్రేణి ఇది సులభమైన మరియు సమర్థవంతమైన మెమరీ నిర్వహణను అందిస్తుంది. మాన్యువల్ మెమరీ కేటాయింపు లేదా డీలోకేషన్ అవసరం లేదని దీని అర్థం.
4: ఆటోమేటిక్ బౌండ్ చెకింగ్
నిజానికి ఆ std::శ్రేణి C-శైలి శ్రేణులపై ఆటోమేటెడ్ హద్దులను తనిఖీ చేయడం దాని ముఖ్య ప్రయోజనాల్లో ఒకటి. దీనర్థం ప్రోగ్రామ్ శ్రేణి యొక్క నిర్వచించిన పరిధికి వెలుపల ఉన్న మూలకాన్ని యాక్సెస్ చేయడానికి ప్రయత్నిస్తే, కంపైలర్ లోపాన్ని ఉత్పత్తి చేస్తుంది. బఫర్ ఓవర్‌ఫ్లోలు, సెగ్మెంటేషన్ లోపాలు మరియు మెమరీ లీక్‌లు తరచుగా ప్రోగ్రామింగ్ సమస్యలలో కొన్ని మాత్రమే ఉన్నాయి, వీటిని నివారించడంలో బౌండ్ చెకింగ్ మీకు సహాయపడుతుంది.
5: ఉపయోగకరమైన విధులను అందిస్తుంది
std::శ్రేణి ఇటరేటర్లు, సైజు(), ఫ్రంట్(), బ్యాక్(), ఫిల్(), మరియు ఎట్() వంటి అనేక సులభ ఫంక్షన్‌లను అందిస్తుంది, ఇది మరొక ప్రయోజనం. ఈ ఫంక్షన్‌లు సంక్లిష్టమైన మరియు ఎర్రర్-ప్రోన్ కోడ్ అవసరం లేకుండా శ్రేణి మూలకాలను మార్చడాన్ని సులభతరం చేస్తాయి. ఇటరేటర్లు, ఉదాహరణకు, శ్రేణి మూలకాల మధ్య నావిగేట్ చేయడాన్ని సులభతరం చేస్తాయి మరియు పూరకం() పద్ధతి శ్రేణి యొక్క మొత్తం మూలకం సెట్‌కు ఒకే విలువను అందించడానికి మిమ్మల్ని అనుమతిస్తుంది.
ముగింపు
C++లో, ది std::శ్రేణి తరగతి కొన్ని ఉపయోగకరమైన విధులు మరియు రకం మరియు శ్రేణి భద్రత యొక్క ప్రయోజనాలతో పాటు స్థిర-పరిమాణ శ్రేణులతో పని చేయడానికి ఒక ఆచరణాత్మక మార్గాన్ని అందిస్తుంది. ప్రారంభించడం మరియు సరిహద్దుల తనిఖీ కోసం, ఇది స్పష్టమైన, మరింత అర్థమయ్యే వాక్యనిర్మాణాన్ని అందిస్తుంది, ఇది అనేక సాధారణ ప్రోగ్రామింగ్ తప్పులను నివారించడంలో సహాయపడుతుంది. స్థిర-పరిమాణ శ్రేణులను ఉపయోగించాల్సిన చాలా సందర్భాలలో, std::array యొక్క ఉపయోగం సూచించబడుతుంది, ఎందుకంటే ఇది వాటిని మార్చడానికి మరింత తాజా మరియు సురక్షితమైన పద్ధతిని అందిస్తుంది.