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