గురించి మరింత సమాచారం కోసం చదవండి అయితే లూప్ C++లో.
C++లో లూప్ అంటే ఏమిటి?
C++ ప్రోగ్రామింగ్‌లో, a కోసం మరొక పేరు అయితే లూప్ ముందుగా పరీక్షించిన లూప్. లూప్ కండిషన్ నిజం అయినంత వరకు నిర్దిష్ట బ్లాక్‌లో కోడ్ స్టేట్‌మెంట్‌లను పదేపదే అమలు చేయడానికి ఇది ప్రోగ్రామ్‌ను అనుమతిస్తుంది. లూప్ మొదట పరిస్థితిని పరీక్షిస్తుంది; షరతు నిజమైతే, లూప్ బ్రాకెట్‌లలోని కోడ్ మొదట అమలు చేయబడుతుంది మరియు లూప్ పదేపదే కోడ్‌ను అమలు చేస్తుంది, నిర్దిష్ట పరిస్థితి తప్పుగా మారినప్పుడు, లూప్ బ్రాకెట్‌లోని కోడ్ మరియు స్టేట్‌మెంట్‌లు ఇకపై అమలు చేయబడవు.
అయితే లూప్ యొక్క భాగాలు
యొక్క ముఖ్యమైన భాగాలు అయితే లూప్ ఉన్నాయి:
- అయితే కీవర్డ్
- పరీక్ష పరిస్థితి
- ప్రకటనలు
- పెంపు లేదా తగ్గింపు
అయితే లూప్ కోసం సింటాక్స్
యొక్క వాక్యనిర్మాణం అయితే లూప్ C++లో ఈ క్రింది విధంగా ఉంది:
అయితే ( పరిస్థితి పరీక్ష )
{
// పదే పదే అమలు చేయాల్సిన స్టేట్‌మెంట్‌లు
// ఇంక్రిమెంట్ (++) లేదా తగ్గింపు (--) ఆపరేషన్
}
యొక్క ప్రవాహ రేఖాచిత్రం క్రిందిది అయితే లూప్ :
C++లో లూప్ అయితే ఎలా ఉపయోగించాలి
మేము ప్రింట్ చేయాలనుకుంటున్న ఉదాహరణను పరిగణించండి 'Linux' పదింతలు. “printf” స్టేట్‌మెంట్‌ను పదిసార్లు టైప్ చేయడానికి బదులుగా, మనం ఉపయోగించవచ్చు అయితే లూప్ పది పునరావృత్తులు వరకు అమలు చేయడానికి. ఇక్కడ ఒక ఉదాహరణ:
#
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
int లెక్కించండి = 0 ;
అయితే ( లెక్కించండి < 10 ) {
కోట్ << 'Linux \n ' ;
లెక్కించండి ++;
}
తిరిగి 0 ;
}
పై కోడ్ సందేశాన్ని ప్రింట్ చేయడానికి కాసేపు లూప్‌ని ఉపయోగిస్తుంది 'Linux' 10 సార్లు. ఇది కౌంటర్ వేరియబుల్‌ను 0కి ప్రారంభిస్తుంది, ఆపై కౌట్ స్టేట్‌మెంట్‌ను అమలు చేయడానికి మరియు కౌంటర్‌ను 10కి చేరుకునే వరకు పెంచడానికి అయితే లూప్‌ను ఉపయోగిస్తుంది.
C++లో లూప్ అయితే అనంతాన్ని ఎలా ఉపయోగించాలి
కొన్ని సందర్భాల్లో, ది అయితే లూప్ ఎప్పటికీ పరుగెత్తకపోవచ్చు. లూప్ పరిస్థితి తప్పుగా మారినప్పుడు, లూప్ ముగుస్తుంది మరియు లూప్ తర్వాత మొదటి స్టేట్‌మెంట్ ముద్రించబడుతుంది. మీరు ఇన్ఫినిట్ అయితే లూప్‌ని ఉపయోగించాలనుకుంటే, ఎల్లప్పుడూ నిజం అయ్యే షరతును జోడించండి. ఉదాహరణకు, పూర్ణాంకం “a” విలువ ఎల్లప్పుడూ 10 కంటే ఎక్కువగా ఉంటుంది, తద్వారా లూప్ ఎప్పటికీ ముగియదు:
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
int a = 10 ;
అయితే ( a >= 10 )
{
కోట్ << a << ' \n ' ;
a ++;
}
తిరిగి 0 ;
}
గమనిక: ఎల్లప్పుడూ నిజం అనే షరతును పేర్కొనడానికి బదులుగా, 'ట్రూ' కీవర్డ్‌ను కాసేపు లూప్‌తో కూడా ఉపయోగించవచ్చు.
లూప్‌లో లాజికల్ ఆపరేటర్‌లను ఎలా ఉపయోగించాలి - C++
లాజికల్ ఆపరేటర్లు ఇష్టపడతారు మరియు (&&) మరియు లేదా (||) లో కూడా ఉపయోగించవచ్చు అయితే లూప్ . మీరు AND ఆపరేటర్‌ని ఉపయోగిస్తుంటే, అమలు చేయడానికి రెండు షరతులు తప్పనిసరిగా ఉండాలి అయితే లూప్ , మరియు మీరు ఉపయోగిస్తుంటే లేదా ఆపరేటర్, రెండు షరతులు తప్పు అయ్యే వరకు లూప్ రన్ అవుతుంది.
#నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
int x = 1 , మరియు = 1 ;
అయితే ( ( x <= 5 && మరియు <= 5 ) || x + మరియు <= 10 ) {
కోట్ << 'x:' << x << ', మరియు:' << మరియు << endl ;
x ++;
మరియు ++;
}
తిరిగి 0 ;
}
పై కోడ్ లాజికల్ మరియు లాజికల్ లేదా ఆపరేటర్లు రెండింటి వినియోగాన్ని ప్రదర్శిస్తుంది a అయితే లూప్ . షరతుల్లో ఏది నిజం అయినంత వరకు లూప్ అమలులో కొనసాగుతుంది:
క్రింది గీత
ది అయితే లూప్ C++లో ఒక నిర్దిష్ట షరతుపై ఆధారపడి కోడ్ యొక్క బ్లాక్‌ని పదేపదే అమలు చేయడానికి అనుమతిస్తుంది. ఇది C++ ప్రోగ్రామింగ్‌లో ముఖ్యమైన భాగం, ఇది కోడ్‌ను సంక్షిప్తంగా మరియు సులభంగా నిర్వహించేలా చేస్తుంది. యొక్క వాక్యనిర్మాణం అయితే లూప్ పరీక్షించాల్సిన షరతు, పదేపదే అమలు చేయాల్సిన స్టేట్‌మెంట్‌లు మరియు ముగింపులో ఇంక్రిమెంట్ లేదా డిక్రిమెంట్ ఆపరేషన్ ఉంటాయి. AND మరియు OR వంటి లాజికల్ ఆపరేటర్‌లను కాసేపు లూప్‌లో ఉపయోగించవచ్చు, అంతే కాకుండా ఎల్లప్పుడూ నిజమైన షరతును ఉపయోగించడం ద్వారా అనంతమైన లూప్‌ను కూడా సృష్టించవచ్చు.