సి ప్రోగ్రామింగ్‌లో నిర్ణయం ఏమిటి?
సి ప్రోగ్రామింగ్‌లో, నిర్ణయం తీసుకోవడం సమర్థవంతమైన ప్రోగ్రామ్‌లను రూపొందించడానికి ప్రోగ్రామర్లు ప్రావీణ్యం పొందవలసిన ప్రధాన నైపుణ్యం. నిర్ణయం తీసుకోవడం అనేది వివిధ పరిస్థితులను మూల్యాంకనం చేయడం మరియు ఫలితాల ఆధారంగా ఉత్తమమైన చర్యను ఎంచుకోవడం. if-else స్టేట్‌మెంట్‌తో, నిర్ణయం తీసుకోవడం C లో అమలు చేయబడింది. నిర్ణయాలు షరతులపై ఆధారపడి ఉంటాయి మరియు if-else స్టేట్‌మెంట్‌ని ఉపయోగించి తీసుకోబడతాయి. షరతు నిజమైతే, కోడ్ నడుస్తుంది; మరోవైపు, అది తప్పు అయితే, else స్టేట్‌మెంట్‌లో ఉన్న కోడ్ అమలు చేయబడుతుంది.
సి ప్రోగ్రామింగ్‌లో బ్రాంచింగ్ అంటే ఏమిటి?
సి ప్రోగ్రామింగ్‌లో, శాఖలు షరతు యొక్క ఫలితం ఆధారంగా అమలు యొక్క ప్రవాహాన్ని మార్చడానికి అనుమతించే సాంకేతికత. బ్రాంచింగ్ నిర్దిష్ట పరిస్థితి యొక్క ఫలితాన్ని బట్టి నిర్దిష్ట కోడ్ బ్లాక్‌లను అమలు చేయడానికి ప్రోగ్రామ్‌ని అనుమతిస్తుంది.
సి ప్రోగ్రామింగ్‌లో వివిధ రకాల బ్రాంచ్‌లు ఉన్నాయి ఉంటే-లేకపోతే , మారండి , మరియు షరతులతో కూడిన ఆపరేటర్లు . a లో ప్రకటన మారండి , ప్రోగ్రామ్ విలువను మూల్యాంకనం చేస్తుంది మరియు అందుబాటులో ఉన్న కేసుల జాబితా నుండి సంబంధిత ఎంపికను ఎంచుకుంటుంది. షరతులతో కూడిన ఆపరేటర్లు షార్ట్‌హ్యాండ్ ఉంటే-లేకపోతే మీరు చిన్న కోడ్ వ్రాయడానికి అనుమతించే ప్రకటనలు.
సి ప్రోగ్రామింగ్‌లో నిర్ణయాలు మరియు శాఖలు
ది నిర్ణయం తీసుకోవడం C ప్రోగ్రామింగ్‌లోని ప్రక్రియలో ప్రోగ్రామ్ అమలు యొక్క ప్రవాహాన్ని నియంత్రించడానికి షరతులతో కూడిన స్టేట్‌మెంట్‌ల ఉపయోగం ఉంటుంది. బ్రాంచింగ్ నిర్దిష్ట పరిస్థితుల ఫలితం ఆధారంగా వివిధ కోడ్ సెట్‌లను అమలు చేయడానికి ప్రోగ్రామ్‌ని అనుమతిస్తుంది.
సి ప్రోగ్రామింగ్‌లో, నిర్ణయం తీసుకోవడం , మరియు శాఖలు దీని ద్వారా సాధించబడతాయి:
- ప్రకటన ఉంటే
- if-else ప్రకటన
- ప్రకటన మారండి
- గూడు ఉంటే
- else-అయితే నిచ్చెన
- బ్రేక్ స్టేట్మెంట్
- ప్రకటనను కొనసాగించండి
1: స్టేట్మెంట్ అయితే
యొక్క సరళమైన పద్ధతి నిర్ణయాలు తీసుకోవడం C ప్రోగ్రామింగ్ ద్వారా అందించబడుతుంది ప్రకటన ఉంటే . ది ప్రకటన ఉంటే ఇచ్చిన షరతును పరీక్షిస్తుంది మరియు షరతు నిజమైతే స్టేట్మెంట్ బాడీలోని కోడ్‌ను అమలు చేస్తుంది. లేకపోతే, ప్రోగ్రామ్ దానితో అనుబంధించబడిన కోడ్ బ్లాక్‌ను విస్మరిస్తుంది ప్రకటన ఉంటే , మరియు ఇది తదుపరి కోడ్‌తో కొనసాగుతుంది.
కోసం వాక్యనిర్మాణం if-స్టేట్మెంట్ ఉంది:
ఉంటే ( పరిస్థితి )
{
ప్రకటనల బ్లాక్;
}
దిగువ కోడ్‌ను చూడండి:
#పూర్ణాంక ప్రధాన ( )
{
పూర్ణాంక సంఖ్య = ఇరవై ;
ఉంటే ( ఒకదానిపై > 5 )
{
printf ( 'సంఖ్య 5 కంటే ఎక్కువ \n ' ) ;
}
printf ( 'సంఖ్య విలువ : %d \n ' , ఒకదానిపై ) ;
తిరిగి 0 ;
}
పై కోడ్ వేరియబుల్‌ను నిర్వచిస్తుంది ' ఒకదానిపై ” 20 విలువతో మరియు అది 5 కంటే ఎక్కువ ఉందో లేదో తనిఖీ చేయడానికి if స్టేట్‌మెంట్‌ని ఉపయోగిస్తుంది. ఒకవేళ ఉంటే, ప్రోగ్రామ్ ప్రింట్ చేస్తుంది “ సంఖ్య 5 కంటే ఎక్కువ '. చివరగా, ఇది '' విలువను ముద్రిస్తుంది. ఒకదానిపై '.
అవుట్‌పుట్
2: if-else స్టేట్మెంట్
if-else స్టేట్మెంట్ అనేది if స్టేట్మెంట్ యొక్క మార్పు, ఇది షరతు ఒప్పు లేదా తప్పు అనే దాని ఆధారంగా వివిధ కోడ్ బ్లాక్‌లను అమలు చేయడానికి అనుమతిస్తుంది.
ఉంటే ( పరిస్థితి ) {// అమలు చేయడానికి కోడ్ ఉంటే పరిస్థితి ఉంది నిజం
} లేకపోతే {
// అమలు చేయడానికి కోడ్ ఉంటే పరిస్థితి ఉంది తప్పుడు
}
ఫలితంగా, షరతు నిజమైతే మొదటి కోడ్ బ్లాక్ అమలు చేయబడుతుంది మరియు షరతు తప్పు అయితే రెండవ కోడ్ బ్లాక్ అమలు చేయబడుతుంది.
కింది కోడ్‌ను ఉదాహరణగా పరిగణించండి:
#పూర్ణాంక ప్రధాన ( )
{
పూర్ణాంక సంఖ్య = 10 ;
ఉంటే ( ఒకదానిపై > 5 )
{
printf ( 'సంఖ్య 5 కంటే ఎక్కువ \n ' ) ;
} లేకపోతే {
printf ( 'సంఖ్య 10 కంటే తక్కువ' ) ;
}
తిరిగి 0 ;
}
పై ప్రోగ్రామ్ వేరియబుల్ సంఖ్యను సృష్టిస్తుంది మరియు దానికి విలువ 10 ఇస్తుంది. ఆపై, ఒక ఉపయోగించి ప్రకటన ఉంటే , అది నిర్ణయిస్తుంది ' ఒకదానిపై ”5 కంటే పెద్దది. సంఖ్య 5 కంటే పెద్దది 'అయితే ' ముద్రించబడుతుంది ఒకదానిపై '5 మించిపోయింది. ఇది ప్రదర్శిస్తుంది' సంఖ్య 10 కంటే తక్కువ ”సంఖ్య 5 కంటే ఎక్కువ లేకపోతే. ప్రోగ్రామ్ 0ని అందిస్తుంది, ఇది విజయవంతంగా అమలు చేయబడిందని సూచిస్తుంది.
అవుట్‌పుట్
3: స్టేట్మెంట్ మారండి
కోసం మరొక ముఖ్యమైన సాధనం నిర్ణయం తీసుకోవడం సి ప్రోగ్రామింగ్‌లో ఉంది మారండి ప్రకటన. ది మారండి ప్రకటన వంటి నిర్దిష్ట పరిస్థితుల కోసం తనిఖీ చేస్తుంది if-else ప్రకటనలు చేయండి, కానీ అది ఆ పరిస్థితికి అనేక అవకాశాలను తనిఖీ చేయవచ్చు. మేము అనేక విభిన్న ఫలితాలతో వ్యవహరిస్తున్నప్పుడు ఇది సహాయకరంగా ఉంటుంది.
ఉపయోగించడానికి వాక్యనిర్మాణం ప్రకటన మారండి సి ప్రోగ్రామింగ్‌లో:
మారండి ( వ్యక్తీకరణ ) {కేసు స్థిరాంకం1:
// అమలు చేయడానికి కోడ్ ఉంటే వ్యక్తీకరణ స్థిరాంకం1కి సమానం
బ్రేక్ ;
కేసు స్థిరాంకం2:
// అమలు చేయడానికి కోడ్ ఉంటే వ్యక్తీకరణ స్థిరాంకం2కి సమానం
బ్రేక్ ;
...
డిఫాల్ట్:
// అమలు చేయడానికి కోడ్ ఉంటే కేసులు ఏవీ సరిపోలలేదు
బ్రేక్ ;
}
వ్యక్తీకరణ ఈ సందర్భంలో అంచనా వేయబడుతున్న వేరియబుల్, మరియు కేసు ప్రకటనలు దానితో పోల్చిన విలువలను చేర్చండి.
కింది కోడ్‌ను ఉదాహరణగా పరిగణించండి:
#పూర్ణాంక ప్రధాన ( ) {
పూర్ణాంక సంఖ్య = 2 ;
మారండి ( ఒకదానిపై ) {
కేసు 1 :
printf ( 'సంఖ్య 1' ) ;
బ్రేక్ ;
కేసు 2 :
printf ( 'సంఖ్య 2' ) ;
బ్రేక్ ;
కేసు 3 :
printf ( 'సంఖ్య 3' ) ;
బ్రేక్ ;
డిఫాల్ట్:
printf ( '1, 2 మరియు 3 కాకుండా ఇతర సంఖ్య' ) ;
బ్రేక్ ;
}
తిరిగి 0 ;
}
వేరియబుల్ విలువను పరిశీలించడానికి స్విచ్ స్టేట్‌మెంట్‌ను ఎలా ఉపయోగించాలో పై ప్రోగ్రామ్ చూపిస్తుంది “ ఒకదానిపై ” మరియు సంబంధిత కోడ్ బ్లాక్‌ని అమలు చేయండి. ఈ సందర్భంలో, నుండి ' ఒకదానిపై ” 2కి ప్రారంభించబడింది, అవుట్‌పుట్ “ సంఖ్య 2 '.
అవుట్‌పుట్
4: నెస్ట్ అయితే
స్టేట్‌మెంట్‌లైతే నెస్టెడ్ ఇతర నెస్టెడ్ ఇఫ్ స్టేట్‌మెంట్‌లలో పొందుపరచబడిన బ్రాంచ్ స్టేట్‌మెంట్‌లు. ఇది ఇతర షరతులతో కూడిన స్టేట్‌మెంట్‌లలో బహుళ పరిస్థితులను తనిఖీ చేయడం ద్వారా మరింత సంక్లిష్టమైన శాఖల తర్కాన్ని అనుమతిస్తుంది. లోపలి ప్రకటనలు ఉంటే ఔటర్ ఇఫ్ స్టేట్‌మెంట్‌లు ఒప్పు అని మూల్యాంకనం చేస్తే మాత్రమే అమలు చేయబడతాయి.
కోసం ప్రాథమిక వాక్యనిర్మాణం ప్రకటనలు ఉంటే గూడు క్రింద ఇవ్వబడ్డాయి:
ఉంటే ( పరిస్థితి ) {ఉంటే ( వ్యక్తీకరణ ) {
ప్రకటనల బ్లాక్;
} లేకపోతే {
ప్రకటనల బ్లాక్;
}
} లేకపోతే {
ప్రకటనల బ్లాక్;
}
కింది కోడ్‌ను ఉదాహరణగా పరిగణించండి:
#పూర్ణాంక ప్రధాన ( ) {
int num1 = 1 ;
పూర్ణ సంఖ్య2 = పదిహేను ;
పూర్ణ సంఖ్య3 = 7 ;
ఉంటే ( సంఖ్య1 > సంఖ్య2 ) {
ఉంటే ( సంఖ్య1 > సంఖ్య3 ) {
printf ( 'num1=1 అనేది అతిపెద్ద సంఖ్య \n ' ) ;
}
లేకపోతే {
printf ( 'num3=7 అనేది అతిపెద్ద సంఖ్య \n ' ) ;
}
}
లేకపోతే {
ఉంటే ( సంఖ్య2 > సంఖ్య3 ) {
printf ( 'num2=15 అనేది అతిపెద్ద సంఖ్య \n ' ) ;
}
లేకపోతే {
printf ( 'num3=7 అనేది అతిపెద్ద సంఖ్య \n ' ) ;
}
}
తిరిగి 0 ;
}
పై ప్రోగ్రామ్ మూడు పూర్ణాంకాలను పోల్చింది, “ సంఖ్య1 ',' సంఖ్య2 ', మరియు' సంఖ్య3 “, మరియు ఏది అతిపెద్ద సంఖ్య అని నిర్ధారించడానికి nested if స్టేట్‌మెంట్‌లను ఉపయోగిస్తుంది. ఇది మొదట పోల్చింది ' సంఖ్య1 'మరియు' సంఖ్య2 ', ఆపై ఆ రెండింటిలో పెద్దదానిని పోల్చి చూస్తుంది' సంఖ్య3 '. ఏ వేరియబుల్ అతిపెద్ద విలువను కలిగి ఉందో అవుట్‌పుట్ సూచిస్తుంది.
అవుట్‌పుట్
5: else-అయితే నిచ్చెన
అనేక ప్రమాణాలు సీక్వెన్షియల్ ఆర్డర్‌లో ఉన్నప్పుడు సంక్లిష్టమైన సమస్యను మనం సులభంగా పరిష్కరించవచ్చు నిచ్చెన-ఉంటే లేదా లేకపోతే వ్యక్తీకరణ .
కోసం వాక్యనిర్మాణం క్రింద ఉంది else-ఒకవేళ నిచ్చెన ప్రకటన:
ఉంటే ( షరతు1 ){
ప్రకటనల బ్లాక్;
}
లేకపోతే ఉంటే ( షరతు2 )
{
ప్రకటనల బ్లాక్;
}
లేకపోతే ఉంటే ( షరతు3 )
{
ప్రకటనల బ్లాక్;
}
లేకపోతే
{
డిఫాల్ట్ ప్రకటన
}
కింది కోడ్‌ను ఉదాహరణగా పరిగణించండి:
#పూర్ణాంక ప్రధాన ( ) {
int marks = 80 ;
ఉంటే ( మార్కులు > = 90 && మార్కులు = 80 && మార్కులు = 70 && మార్కులు = 60 && మార్కులు = యాభై && మార్కులు < 60 ) {
printf ( 'గ్రేడ్: D' ) ;
}
లేకపోతే {
printf ( 'గ్రేడ్: ఫెయిల్' ) ;
}
తిరిగి 0 ;
}
పైన ఉన్న ప్రోగ్రామ్ ఉపయోగిస్తుంది if- else లాజిక్ వేరియబుల్ 'మార్కులు' యొక్క ప్రస్తుత విలువ ప్రకారం గ్రేడ్‌ను నిర్ణయించడానికి. 'మార్కుల' విలువపై ఆధారపడి, ప్రోగ్రామ్ A+ నుండి ఫెయిల్ వరకు సంబంధిత గ్రేడ్‌ను అవుట్‌పుట్ చేస్తుంది.
అవుట్‌పుట్
6: ప్రకటనను విచ్ఛిన్నం చేయండి
ది విరామం ప్రకటన C ప్రోగ్రామింగ్‌లో ఒక ముఖ్యమైన నియంత్రణ ప్రవాహ ప్రకటన, ఇది ప్రోగ్రామర్లు లూప్‌ల ప్రవర్తనను నియంత్రించడానికి మరియు స్టేట్‌మెంట్‌లను మార్చడానికి అనుమతిస్తుంది. ది విరామం ప్రకటన C ప్రోగ్రామింగ్‌లో రెండు అప్లికేషన్లు ఉన్నాయి:
- ఒక లూప్ చేరుకున్నప్పుడు a బ్రేక్ ప్రకటన, ఇది తక్షణమే నిలిపివేయబడుతుంది మరియు ప్రోగ్రామ్ నియంత్రణ లూప్‌ను అనుసరించే స్టేట్‌మెంట్‌కు అప్పగించబడుతుంది.
- ఇది స్విచ్ స్టేట్‌మెంట్‌కు ఉపయోగించడం ద్వారా కేసును ముగించడానికి ఉపయోగించవచ్చు.
కోసం వాక్యనిర్మాణం బ్రేక్ ప్రకటన:
బ్రేక్ ;ఉదాహరణ కోడ్‌ను చూడండి:
#పూర్ణాంక ప్రధాన ( ) {
పూర్ణాంక సంఖ్య = 12 ;
అయితే ( ఒకదానిపై పదిహేను ) {
బ్రేక్ ;
}
}
తిరిగి 0 ;
}
C కోడ్ యొక్క ఈ భాగం పూర్ణాంకం వేరియబుల్ ఉన్నంత వరకు అమలు చేసే కాసేపు లూప్‌ను ప్రకటించింది “ ఒకదానిపై ” 22 కంటే తక్కువ మరియు దానిని 12కి ప్రారంభిస్తుంది. లూప్‌లో, “ ఒకదానిపై ” 1 ద్వారా పెంచబడింది మరియు దాని విలువ ఉపయోగించి కన్సోల్‌కు నివేదించబడుతుంది printf . లూప్ అప్పుడు a తో ముగించబడుతుంది “సంఖ్య” అయితే స్టేట్మెంట్ విచ్ఛిన్నం if స్టేట్మెంట్ ద్వారా నిర్ణయించబడినట్లుగా 15 కంటే పెద్దది. ఈ కోడ్ 12 మరియు 15 (కలిసి) మధ్య “సంఖ్య” విలువలను ముద్రించిన తర్వాత లూప్‌ను సమర్థవంతంగా ముగిస్తుంది. ప్రోగ్రామ్ 0ని తిరిగి ఇవ్వడం ద్వారా ముగుస్తుంది, ఇది సరిగ్గా నడుస్తుందని చూపుతుంది.
అవుట్‌పుట్
7: స్టేట్మెంట్ కొనసాగించండి
సి ప్రోగ్రామింగ్‌లో, ది కొనసాగుతుంది ప్రకటనను పోలి ఉంటుంది బ్రేక్ ప్రకటన. రద్దును విధించడానికి బదులుగా, ఇది లూప్ యొక్క తదుపరి పునరావృతాన్ని బలవంతం చేస్తుంది మరియు మధ్యలో ఏదైనా కోడ్‌ను దాటవేస్తుంది. లూప్ యొక్క షరతులతో కూడిన పరీక్ష మరియు ఇంక్రిమెంట్ విభాగాలు దీని ద్వారా అమలు చేయబడతాయి కొనసాగుతుంది వ్యక్తీకరణ. అయితే మరియు డూ-వైల్ లూప్‌ల షరతులతో కూడిన పరీక్షలు ప్రోగ్రామ్ నియంత్రణ ద్వారా ఆమోదించబడతాయి కొనసాగుతుంది ప్రకటన.
యొక్క సింటాక్స్ ప్రకటనలను కొనసాగించండి ఉంది:
కొనసాగుతుంది ;ఈ ఉదాహరణ చూడండి.
#పూర్ణాంక ప్రధాన ( ) {
పూర్ణాంక సంఖ్య = 12 ;
అయితే ( ఒకదానిపై పదిహేను ) {
కొనసాగుతుంది ;
}
}
తిరిగి 0 ;
}
పై ప్రోగ్రామ్‌లోని లూప్ వేరియబుల్ విలువను ప్రింట్ చేయడానికి ఉపయోగించబడుతుంది “ ఒకదానిపై ” 22 కంటే తక్కువ ఉంటే. ఒకదానిపై ” లూప్ సమయంలో 15 మించిపోయింది, ది కొనసాగుతుంది ప్రకటన అమలు చేయబడుతుంది మరియు లూప్ యొక్క ప్రస్తుత పునరావృతం దాటవేయబడింది. ఈ సందర్భంలో, లూప్ ఐదుసార్లు అమలు చేయబడుతుంది, ప్రతిసారీ “సంఖ్య” విలువను ముద్రిస్తుంది, “” వరకు ఒకదానిపై ”16కి చేరుకుంటుంది మరియు లూప్ పునరావృతాన్ని దాటవేస్తుంది, ఇక్కడ” ఒకదానిపై ” 16, ఆపై లూప్ ముగిసే వరకు మిగిలిన పునరావృతాలతో కొనసాగుతుంది.
అవుట్‌పుట్
ముగింపు
నిర్ణయం తీసుకోవడం మరియు శాఖలు వివిధ వాస్తవ-ప్రపంచ పరిస్థితులను నిర్వహించే సంక్లిష్టమైన, ఇంటరాక్టివ్ అప్లికేషన్‌లను రూపొందించడానికి అనుమతించే C భాష యొక్క క్లిష్టమైన భాగాలు. షరతులతో కూడిన స్టేట్‌మెంట్‌లు, if-else మరియు స్విచ్, సృష్టించడానికి ఉపయోగించే ప్రాథమిక సందర్భాలు నిర్ణయం ఆధారిత అల్గోరిథంలు. అయినప్పటికీ శాఖలు కోడ్‌ల సంస్థలో సవాలుగా మారవచ్చు, సరైన ప్రణాళిక మరియు అమలుతో, ప్రోగ్రామర్లు నిర్దిష్ట అవసరాలకు అనుగుణంగా సమర్థవంతమైన మరియు లోపం లేని ప్రోగ్రామ్‌లను సృష్టించగలరు.