ఉదాహరణ 1:
'iostream' హెడర్ ఫైల్ ఈ కోడ్‌లో చేర్చబడింది. ఈ హెడర్ ఫైల్‌లో ఇన్‌పుట్ లేదా అవుట్‌పుట్ ఫంక్షన్‌లు ప్రకటించబడినందున ఈ హెడర్ ఫైల్ C++లో ఉపయోగించబడుతుంది. దీని తరువాత, మేము 'std' నేమ్‌స్పేస్‌ని ఉంచుతాము మరియు ఆపై 'ప్రధాన()' ఫంక్షన్‌ను అమలు చేస్తాము. మేము “a” వేరియబుల్‌ని పూర్ణాంక డేటా రకంగా ప్రారంభించి, ఆపై “for” లూప్‌ను ఉంచుతాము. ఈ లూప్‌లో, మేము “a = 0”ని ఉంచుతాము మరియు మేము ఇక్కడ జోడించే షరతు “a <= 9”. అప్పుడు, మేము దానిని 'a' విలువలో పెంచుతాము. కింది వాటిలో, మేము “a == 5”ని చొప్పించే “if” కండిషన్‌ను ఉపయోగిస్తాము మరియు దీని తర్వాత “continue” స్టేట్‌మెంట్‌ను ఉంచుతాము. 'కొనసాగించు' స్టేట్‌మెంట్‌లు ఈ లూప్ నుండి '5' విలువను దాటవేయడంలో సహాయపడతాయి. అప్పుడు, మేము 'కౌట్' ను జోడించి, మిగిలిన సంఖ్యలను ప్రింట్ చేస్తాము. మేము 'కొనసాగించు' స్టేట్‌మెంట్‌ను జోడించినప్పటి నుండి ఇది '5' మినహా అన్ని సంఖ్యలను రెండర్ చేస్తుంది.
కోడ్ 1:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
int a ;
కోసం ( a = 0 ; a <= 9 ; a ++ ) {
ఉంటే ( a == 5 ) {
కొనసాగుతుంది ;
}
కోట్ << 'సంఖ్య ఇది' << a << endl ;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇక్కడ, అన్ని సంఖ్యలు రెండర్ చేయబడ్డాయి, కానీ ఈ అవుట్‌పుట్ నుండి “5” సంఖ్య దాటవేయబడింది మరియు ఈ లూప్ నుండి “5” సంఖ్యను దాటవేయడానికి మేము “కొనసాగించు” స్టేట్‌మెంట్‌ను జోడించినందున ఇక్కడ అందించబడలేదు.
ఉదాహరణ 2:
మేము 'అయితే' లూప్ లోపల 'కొనసాగించు' స్టేట్‌మెంట్‌ను ఉపయోగిస్తాము. ఈ హెడర్ ఫైల్‌లో ఇన్‌పుట్ మరియు అవుట్‌పుట్ పద్ధతులు ప్రకటించబడినందున కోడ్ “iostream” హెడర్ ఫైల్‌ను కలిగి ఉంటుంది. అప్పుడు “std” నేమ్‌స్పేస్ జోడించబడుతుంది మరియు “main()” ఫంక్షన్‌ని ఇక్కడ పిలుస్తారు. దీని తరువాత, మేము 'int'ని ఉంచుతాము మరియు 'num' పేరుతో పూర్ణాంక వేరియబుల్‌ను ప్రారంభించాము. దీని తరువాత, మేము “while()” లూప్‌ని ఉపయోగిస్తాము మరియు “num <= 12” షరతును ఉంచుతాము.
దీని క్రింద, 'num == 7' అనే మరొక షరతును కలిగి ఉన్న 'if'ని ఉంచాము. అప్పుడు, మేము 'num++'ని ఉంచుతాము, ఇది 'num' విలువలో ఒకటి పెరుగుతుంది. దీని తరువాత, మేము 'కొనసాగించు' ప్రకటనను ఉపయోగిస్తాము. ఈ 'కొనసాగించు' ప్రకటన 'వేళ' లూప్ నుండి '7' సంఖ్యను దాటవేస్తుంది. 'కౌట్' జోడించబడింది మరియు మిగిలిన సంఖ్యలు ముద్రించబడతాయి. మేము “కొనసాగించు” స్టేట్‌మెంట్‌ను చొప్పించినందున, ఇది “7” కాకుండా అన్ని సంఖ్యలను రెండర్ చేస్తుంది. దీని తరువాత, 'num' విలువను పెంచడానికి మేము 'num++'ని ఉంచుతాము.
కోడ్ 2:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
int ఒకదానిపై = 0 ;
అయితే ( ఒకదానిపై <= 12 ) {
ఉంటే ( ఒకదానిపై == 7 ) {
ఒకదానిపై ++;
కొనసాగుతుంది ;
}
కోట్ << 'మేము అయితే లూప్ ఉపయోగించి సంఖ్యను ప్రదర్శిస్తాము' << ఒకదానిపై << endl ;
ఒకదానిపై ++;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఈ సందర్భంలో అన్ని సంఖ్యలు ముద్రించబడినందున, “7” సంఖ్యను స్కిప్ చేయడానికి లూప్‌కు “కొనసాగించు” ప్రకటన జోడించబడినందున, “7” సంఖ్య అవుట్‌పుట్ నుండి విస్మరించబడింది మరియు రెండర్ చేయబడదు.
ఉదాహరణ 3:
మేము ఈ 'కొనసాగించు' ప్రకటనను సమూహ 'కోసం' లూప్ లోపల జోడిస్తాము. హెడర్ ఫైల్ మరియు “std” నేమ్‌స్పేస్‌ని ఇన్‌సర్ట్ చేసిన తర్వాత, మేము “main()” పద్ధతిని అమలు చేస్తాము. “n1” మరియు “n2” వేరియబుల్స్ ఇక్కడ పూర్ణాంకం రకంగా ప్రకటించబడ్డాయి. ఇప్పుడు, మేము 'n1 <= 4' షరతును కలిగి ఉన్న 'ఫర్' లూప్‌ని ఉపయోగిస్తాము. దీని క్రింద, మేము 'ఫర్' లూప్‌ను మళ్లీ ఉంచుతాము, ఇది 'నెస్టెడ్ ఫర్' లూప్. రెండవ “ఫర్” లూప్ “n2 <= 4” అని చెప్పే షరతును కలిగి ఉంది.
ఇప్పుడు, మేము షరతును జోడించి, '&&' ఆపరేటర్‌ని ఉపయోగించే “if”ని ఉపయోగిస్తాము. 'కొనసాగించు' ఇక్కడ జోడించబడింది. ఇది “n1” “3” మరియు “n2” “3” అయిన విలువలను మాత్రమే దాటవేస్తుంది. “n1” మరియు “n2” రెండూ ”3” అయినప్పుడు, అది ఇక్కడ లూప్ యొక్క పునరావృతాన్ని దాటవేస్తుంది. అప్పుడు, మిగిలిన విలువలను అందించడానికి మేము దీని క్రింద ఉన్న 'కౌట్' ను ఉపయోగిస్తాము.
కోడ్ 3:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
int n1 , n2 ;
కోసం ( n1 = 1 ; n1 <= 4 ; n1 ++ ) {
కోసం ( n2 = 1 ; n2 <= 4 ; n2 ++ ) {
ఉంటే ( n1 == 3 && n2 == 3 ) {
కొనసాగుతుంది ;
}
కోట్ << 'n1 =' << n1 << 'n2 =' << n2 << endl ;
}
}
}
అవుట్‌పుట్:
రెండు వేరియబుల్ విలువలు “3” మరియు అన్ని ఇతర విలువలు ఇక్కడ ముద్రించబడిన పునరావృతాన్ని దాటవేయడానికి సమూహ లూప్‌కు “కొనసాగించు” లైన్ జోడించబడినందున.
ఉదాహరణ 4:
“num_1” పేరుతో ఉన్న “int” వేరియబుల్ “1” విలువతో ప్రారంభించబడింది. అప్పుడు, మేము “while” లూప్‌ని ఉపయోగిస్తాము మరియు “num_1 <= 9” షరతును జోడిస్తాము. దీని క్రింద, 'కౌట్' చేర్చబడింది మరియు అక్కడ 'ఇఫ్' షరతు ఉంచబడుతుంది. 'if' షరతు మనం దానిని '2'తో విభజించినప్పుడు సున్నాకి సమానమైన సంఖ్యను తనిఖీ చేస్తుంది. మన కోడ్‌లో సరి సంఖ్యను తనిఖీ చేయాలనుకున్నప్పుడు ఈ షరతు జోడించబడుతుంది. దిగువన, 'num_1' విలువను పెంచడానికి మేము 'num_1++'ని ఉంచుతాము. ఇక్కడ, మేము లూప్ నుండి సరి సంఖ్యలను దాటవేయడానికి “కొనసాగించు”ని ఉపయోగిస్తాము మరియు లూప్‌లో ఉన్న సరి సంఖ్య కోసం ఇచ్చిన సందేశాన్ని అందించము.
కోడ్ 4:
#includeనేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
int సంఖ్య_1 = 1 ;
అయితే ( సంఖ్య_1 <= 9 ) {
కోట్ << 'సంఖ్య =' << సంఖ్య_1 << endl ;
ఉంటే ( సంఖ్య_1 % 2 == 0 ) {
సంఖ్య_1 ++;
కొనసాగుతుంది ;
}
కోట్ << 'సంఖ్య ఇది' << సంఖ్య_1 << 'ఇది బేసి సంఖ్య' << endl ;
సంఖ్య_1 ++;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇక్కడ, మనం మన కోడ్‌లో చొప్పించిన “కొనసాగించు” స్టేట్‌మెంట్ కారణంగా అవుట్‌పుట్ నుండి సరి సంఖ్యలు తొలగించబడిందని మరియు బేసి సంఖ్యకు సంబంధించిన సందేశం ఇక్కడ రెండర్ చేయబడిందని మనం చూడవచ్చు.
ఉదాహరణ 5:
మా చివరి కోడ్‌లో, మేము వినియోగదారు నుండి “45” కంటే తక్కువ విలువలను పొందుతాము మరియు మేము ప్రతికూల విలువను నమోదు చేసినప్పుడు మరియు అందించిన విలువల మొత్తాన్ని లెక్కించినప్పుడు వినియోగదారు ఇన్‌పుట్‌ను రద్దు చేస్తాము. ముందుగా, మేము పూర్ణాంక డేటా రకాలుగా “సమ్మషన్” మరియు “విలువ”ను ప్రారంభిస్తాము.
అప్పుడు, విలువ సానుకూలంగా ఉందో లేదో తనిఖీ చేయండి. ఆపై, విలువ సానుకూలంగా ఉంటే “సమ్మషన్ + = విలువ” వర్తింపజేయండి మరియు “మొత్తానికి సంఖ్యను నమోదు చేయండి”కి సందేశాన్ని అందించండి. దీని క్రింద, మేము సంఖ్యను పొందడానికి మరియు దానిని 'విలువ'లో సేవ్ చేయడానికి 'సిన్'ని ఉపయోగిస్తాము. ఇప్పుడు, మేము ముందుకు సాగి, “విలువ > 45” అని చూస్తాము. ఈ షరతు సంతృప్తి చెందితే, “45” కంటే తక్కువ విలువను నమోదు చేయడానికి మనం సందేశాన్ని వ్రాసిన పంక్తిని తప్పనిసరిగా అమలు చేయాలి. ఆపై, “విలువ = 0”ని కేటాయించి, ఆ విలువను దాటవేసి, వినియోగదారు నుండి కొత్త విలువను పొందే కొనసాగింపు ప్రకటనను ఉంచండి. దీని తరువాత, మేము 'సమ్మషన్' ను లెక్కించి దానిని రెండర్ చేస్తాము. మేము ప్రతికూల విలువను నమోదు చేసినప్పుడు ఈ సమ్మషన్ చేయబడుతుంది.
కోడ్ 5:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
int సమ్మషన్ = 0 ;
int విలువ = 0 ;
అయితే ( విలువ >= 0 ) {
సమ్మషన్ += విలువ ;
కోట్ << 'దయచేసి మొత్తానికి సంఖ్యను నమోదు చేయండి:' ;
ఆహారపు >> విలువ ;
ఉంటే ( విలువ > నాలుగు ఐదు ) {
కోట్ << 'మీరు ఇక్కడ నమోదు చేసిన సంఖ్య 45 కంటే ఎక్కువ, మేము దానిని లెక్కించము' << endl ;
విలువ = 0 ;
కొనసాగుతుంది ;
}
}
కోట్ << 'నమోదు చేసిన సంఖ్య మొత్తం' << సమ్మషన్ << endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఈ ఫలితం మన కోడ్ వినియోగదారు ఇన్‌పుట్‌ను ఎలా పొందుతుందో, సమ్మషన్‌ను వర్తింపజేస్తుంది మరియు మనం “45” కంటే ఎక్కువ విలువను నమోదు చేసినప్పుడు సందేశాన్ని ఎలా ప్రదర్శిస్తుంది. ఇక్కడ, సమ్మషన్ ప్రాసెస్‌లో “45” కంటే ఎక్కువ ఉన్న విలువలు దాటవేయబడి, లెక్కించబడకపోవడాన్ని మనం గమనించవచ్చు. ఎందుకంటే మేము మా కోడ్‌లో ఆ స్థలంలో “కొనసాగించు” ప్రకటనను వర్తింపజేసాము.
ముగింపు
C++ ప్రోగ్రామింగ్‌లోని “కొనసాగించు” కాన్సెప్ట్ ఈ గైడ్‌లో పూర్తిగా అధ్యయనం చేయబడింది. రెండర్ చేయడానికి అవుట్‌పుట్ నుండి కావలసిన విలువను దాటవేయడంలో ఈ “కొనసాగించు” స్టేట్‌మెంట్ ఎలా సహాయపడుతుందో మేము అన్వేషించాము. మేము మా కోడ్‌లలో ఈ “కొనసాగించు” ప్రకటనను ఉపయోగించాము మరియు ప్రతి కోడ్‌తో పాటు ఈ కోడ్‌ల ఫలితాలను వివరించాము. మేము ఈ “కొనసాగించు” స్టేట్‌మెంట్‌ను “ఫర్”, “వైల్” మరియు “నెస్ట్ ఫర్” లూప్ లోపల ఉపయోగించాము.