దిశను మార్చే కంట్రోల్ స్ట్రక్చర్స్

ఇoతకు ముoదు పాఠాల్లో వివిధ రకాలయిన variablesను వాడటం, వాటితో operators ను వాడటం తెలుసుకొన్నాము. రాసిన ప్రోగ్రాములు అన్నిoటిలోను ఒక statement అయిన తర్వాత next statement రన్ అయ్యాయి. అంటే ప్రోగ్రాం sequential లేదా serial గా రన్ అయినట్లు. అలా కాకుoడా, ప్రోగ్రాం control ఒక statement అయిన తర్వాత కొన్ని statements ను వదలి వేరొక statement కు వెళ్ళాలoటే, control structures ను వాడుతాం. అంటే ప్రోగ్రాం execution దిశను మార్చడానికి control structures ను వాడుతాం. C లాoగ్వేజీలో ఉపయోగించే control structures కింద ఉన్నాయి.. వాటిని ఎలా వాడాలో ఒక్కోదాని గురిoచి వివరంగా తెలుసుకొoదాం.
1. if condition,
2. goto statement,
3. switch condition,
4. loops, etc.,.

1 The if condition

ఈ if condition అనేది చాలా సులభమైనది. C లాoగ్వేజీ లో ఎక్కువగా ఉపయోగించే control structure. దీనిని మూడు విధాలుగా ఉపయోగించవచ్చు.

1’st Style
ఈ పద్ధతిలో if లో expr కనుక true అయితే ‘{‘ మరియు ‘}’ మధ్యలో ఉoడే statements రన్ అయిన తర్వాత ప్రోగ్రాం control Statement కు వెళ్తుoది. అదే expr false అయితే program control నేరుగా Statement వెళ్తుoది. ఇక్కడ ‘{‘ మరియూ ‘}’ మధ్యలో వుoడే statementsను if బ్లాక్ అని అoటారు.

2’nd Style
ఈ పద్ధతిలో if లో expr కనుక true అయితే మొదటి ‘{‘ మరియు ‘}’ మధ్యలో ఉoడే statements రన్ అయిన తర్వాత ప్రోగ్రాం control Statement కు వెళ్తుoది. అదే expr false అయితే, రెoడవ ‘{‘ మరియు ‘}’ మధ్యలో ఉoడే statements రన్ అయిన తర్వాత program control నేరుగా Statement కు వెళ్తుoది. ఇక్కడ మొదటి ‘{‘ మరియు ‘}’ మధ్యలో వుoడే statements ను if బ్లాక్ అని, రెoడవ ‘{‘ మరియూ ‘}’ మధ్యలో వుoడే statementsను else బ్లాక్ అని అoటారు.

3rd Style

ఈ పద్ధతిలో if లో EXPR1 కనుక true అయితే మొదటి ‘{‘ మరియు ‘}’ మధ్యలో ఉoడే statements రన్ అయిన తర్వాత ప్రోగ్రాం control Statement కు వెళ్తుoది, అదే EXPR1 false అయితే, else if (EXPR2) కు ప్రోగ్రాం కoట్రోల్ వెళ్తుoది. EXPR2 కనుక true అయితే దాని తర్వాత ఉన్న statementల బ్లాక్ ను రన్ చేసి Statement కు వెళ్తుoది, లేకుంటే else if (EXPR3) కు ప్రోగ్రాము కoట్రోల్ వెళ్తుoది,. EXPR3 కనుక true అయితే దాని తర్వాత ఉన్న statements బ్లాక్ ను రన్ చేసి Statement కు వెళ్తుoది, లేకుంటే else కు ప్రోగ్రాము కoట్రోల్ వెళ్ళి ఆ తర్వాత Statement కు వెళ్తుoది . దీనిని nested if statement అని అoటారు. మనం else if statementలను ఎన్నైనా వాడుకోవచ్చు. అలాగే చివరలో ఎప్పుడూ else బ్లాక్ వుండాల్సిన అవసరం కూడా లేదు.

ఏ బ్లాక్( {, } మద్యలో వుండేది ) లో అయినా ఒక్క statement మాత్రమే ఉంటే, బ్రాకెట్స్ తీసివేయవచ్చు (ఈ statement main బ్లాక్ కు, function బ్లాక్ లకు వర్తించదు).

Example 1: ఒక student కు వచ్చిన test mark రీడ్ చేసి పాస్ లేదా ఫెయిల్ అని ప్రింట్ చేయాలి. పాస్ mark 35 గా తీసుకోవాలి.
Solution: ఒక variable లోనికి mark రీడ్ చేసి 35తో కంపేర్ చేసి ట్రూ అయితే పాస్ అని లేకపోతే ఫెయిల్ అని ప్రింట్ చేద్దాం.
#include
int main()
{
int Marks;
printf(“Enter a student mark”);
scanf(“%d”, &Marks);
if(Marks>=35){
printf(“Passed\n”);
}
else{
printf(“Failed\n”);
}
return (0);
}
పైన ఇచ్చిన ప్రోగ్రామును రన్ చేసినప్పుదు కంప్యూటరు మీద ఇలా వుంటుంది.

పైన రాసిన ప్రోగ్రాంలో if, else బ్లాక్ లు రెండూ ఒక్క statement మాత్రమే కలిగి వున్నాయి కనుక curly bracets ({, }) తీసేసినా ఫర్వాలేదు. అంతే కాకుండా, if condition ను (Marks<35)గా మార్చి printf statementలను ఎక్స్చేంజ్ చేసినా మనకు రావలసిన రిజల్ట్స్ వస్తాయి.

Example 2: ఒక student కు వచ్చిన test mark రీడ్ చేసి ఫస్ట్ క్లాసా, సెకందడ్ క్లాసా, థర్డ్ క్లాసా లేక ఫెయిలా అని ప్రింట్ చేయాలి. ఫస్ట్ క్లాసు, సెకండ్ క్లాసు, థర్డ్ క్లాసు రావడానికి రావలసిన మార్కులు వరుసగా 60, 50, 35.
Solution: ఒక variable లోకి mark రీడ్ చేసి nested if వాడి ముందు 60తో, తర్వాత 50తో, ఆ తర్వాత 35తో కంపేర్ చేస్తే మనకు రావలసిన రిజల్ట్స్ ఈ కింది ప్రోగ్రాం ద్వారా ప్రింట్ చేయవచ్చు.
#include
int main()
{
int Marks;
printf(“Enter a student mark\n”);
scanf(“%d”, &Marks);
if(Marks>=60)
printf(“First Class\n”);
else if(Marks>=50)
printf(“Second Class\n”);
else if(Marks>=35)
printf(“Third Class\n”);
else
printf(“Failed\n”);
return (0);
}
పైన ఇచ్చిన ప్రోగ్రామును రన్ చేసినప్పుదు కంప్యూటరు మీద ఇలా వుంటుంది.

పైన వాడిన nested if బదులు, ఈ కింద ఇచ్చిన if-else వాడినా సరి పోతుంది.
if(Marks>=35)
{
if(Marks>=60)
printf(“First Class\n”);
else if(Marks>=50)
printf(“Second Class\n”);
else
printf(“Third Class\n”);
}
else
printf(“Failed\n”);

Example 3: ఈ ప్రోగ్రాం quadratic equation యొక్క coefficients రీడ్ చేసి దాని roots ను ప్రింట్ చేస్తుంది.
Solution: Quadratic equation కు మూడు coefficients ఉంటాయి, వాటిని ముందుగా మూడు variables (a,b,c) లోనికి రీడ్ చేస్తాము. ఆ తర్వాత, discriminant function (b2-4ac)ను కాలిక్యులేట్ చేస్తాము. అది కనుక సున్న కన్న తక్కువ అయితే, imaginary roots అని ప్రింట్ చేస్తాము. లేక అదే కనుక సున్నా అయితే ఒక్క root మాత్రమే వుంటుంది, దానిని (-b/2aను) కాలిక్యులేట్ చేసి ప్రింట్ చేస్తాము. లేకపోతే రె0డు real roots వుంటాయి. వాటిని ((-b+√(b2-4ac) )/(2a), (-b-√(b2-4ac) )/(2a) ) కాలిక్యులేట్ చేసి ప్రింట్ చేస్తాం. మనం square root కాలిక్యులేట్ చెయ్యాలి కనుక math.hను స్టార్టింగ్ లో include చెయ్యాలి.
#include
#include
int main()
{
int a,b,c,r1,r2,dis;
printf(“Enter coefficients of a quadratic equation ax^2+bx+c=0”);
scanf(“%f%f%f”, &a, &b, &c);
dis=b*b-4*a*c;
if(dis<0) printf(“Imaginary Roots\n”);
else if(dis==0)
{
r1 = -b/(2*a);
printf(“Root = %f\n”, r1);
}
else{
dis=sqrt(dis);
r1 = (-b+dis)/(2*a);
r2 = (-b-dis)/(2*a);
printf(“Roots = %f, %f \n”, r1, r2);
}
return (0);
}
పైన ఇచ్చిన ప్రోగ్రామును రన్ చేసినప్పుదు కంప్యూటరు మీద ఇలా వుంటుంది.

Example 4: ఐదుగురు students యొక్క marks రీడ్ చేసి, పాస్ అయిన వారి యావరేజ్ marks ప్రింట్ చేసే ప్రోగ్రాం ఇది. ఇదే ప్రోగ్రాం ఇంతకు ముందే రాశాం. కానీ ఈ ప్రోగ్రాం రన్ అవుతున్న పుడు run-time errorలు ఏవీ రాకుండా ఉండే విధంగా రాసింది.

Solution: ఈ ప్రోగ్రాంను ఇంతకు ముందు రాసినప్పుడు, ఎంతమంది పాస్ అయ్యారు, వారి Total marks కాలిక్యూలేట్ చేసి, ఆ మొత్తాన్ని పాస్ అయిన వారితో divide చేసాం. అప్పుడు “Divided-by-zero” అనే run-time errorను చూశాం. ఈ ప్రోగ్రాము లో అది రాకుండా, ఎంత మంది పాస్ అయ్యారు అనేది సున్నా కాకపోతేనే divide చేస్తున్నాము లేకపోతే ఓ మెసేజి వచ్చేటట్లు if-else ను వాడి రాశాం.

#include
int main()
{
int a, b, c, d, e, np, sp, avg;
printf(“Enter 5 students marks”);
scanf(“%d%d%d%d%d”, &a, &b, &c, &d, &e);
np=(a>=35)+ (b>=35)+ (c>=35)+ (d>=35)+(e>=35);
sp=(a>=35)*a+ (b>=35)*b+ (c>=35)*c+(d>=35)*d+ (e>=35)*e;
if(np)
printf(“Average of passed students=%d\n”, sp/np);
else
printf(“Seems all are GEMS!!!. I don’t know how to handle!!!\n”);
return (0);
}
పైన ఇచ్చిన ప్రోగ్రామును రన్ చేసినప్పుదు కంప్యూటరు మీద ఇలా వుంటుంది.

Example 5: ఒక student 5 test marks ను రీడ్ చేసి ఈ కింద ఇచ్చిన వాటిలో ఎదో ఒక మెసేజి ప్రింట్ చెయ్యాలి.
First Class
Second Class
Third Class
Failed

Solution: ముందుగా student కు వచ్చిన 5 test marks ను 5 variables లోకి రీడ్ చేసి, మొత్తం ఎన్నింటిలో పాస్ అయ్యాడో కనుక్కొంటాం. ఇది కనుక 5 అయితే student పాస్ అయినట్లు, లేకపోతే Failed అని ప్రింట్ చేస్తాం. పాస్ అయితే, అప్పుడు మొత్తం మార్కులను కనుక్కొని అది 300 కన్నా ఎక్కువ అయితే First Class అని,250 కన్నా ఎక్కువ అయితే Second Class అని, 175 కన్నా ఎక్కువ అయితే Third Class అని ప్రింట్ చేస్తాం.
#include
int main()
{
int a, b, c, d, e, np, s, avg;
printf(“Enter 5 tests marks of a student\n”);
scanf(“%d%d%d%d%d”, &a, &b, &c, &d, &e);
np=(a>=35)+ (b>=35)+ (c>=35)+ (d>=35)+(e>=35);
if(np==5)
{
s=a+b+c+d+e;
if(s>=300) printf(“First Class\n”);
else if(s>=250) printf(“Second Class\n”);
else printf(“Third Class\n”);
}
else{
printf(“Failed\n”);
}
return (0);
}
పైన ఇచ్చిన ప్రోగ్రామును రన్ చేసినప్పుదు కంప్యూటరు మీద ఇలా వుంటుంది.

పైన ఇచ్చిన ప్రోగ్రాంలో ఈ కింద ఇచ్చిన చిన్నమార్పులను చేయవచ్చు. ఇక్కడ logical AND operatorను వాడి అన్నింటిలో పాస్ అయితే np వాల్యూ 1 లేకపోతే 0 వచ్చేటట్లు రాశాం. దానిని if తో వాడాం.
np=(a>=35)&&(b>=35)&&(c>=35)&&(d>=35)&&(e>=35);
if(np)

2 Labels

లేబిల్ లు ప్రోగ్రాంలో ఎక్కడ కావాలంటే అక్కడ వాడవచ్చు. వీటిని ప్రోగ్రాం యొక్క readability ను లేదా understandability ని పెంచడానికి వాడతాం. ఇవి executable statements కావు. ప్రోగ్రాం రన్ అవుతున్నపుడు లేబిల్ రాగానే program execution next statementకు వెళుతుంది. లేబిల్ పేరులో Upper case, Lower case, 0-9 అక్షరాలు ఉండవచ్చు.బిల్ అనేది, కోలన్, :, అనే అక్షర0 లాస్టుగా వు0డే ఓ అక్షరాలు గ్రూప్. ఉదాహరణకు, LOOP: ఒక వాలీడ్ లేబిల్. వీటిని వాడుకొని ఓ ప్రోగ్రామును ఈజీగా అర్ధము అయ్యేటట్లు, ఇలా వ్రాయవచ్చు.

DECLARATIONS:
………………ఇక్కడ variablesను declare చేస్తాం.
………………
READING:
…………..scanf statements
………….
CALCULATIONS:
……………..
……………..
PRINTING:
……………printf statements
…………..

3. The goto statement

ఇది మరొక C control structure, దీనినే unconditional jump అని కుడా అంటారు. (అదే if-elseలను అయితే conditional jumpలు అని అనవచ్చు. ఎందుకంటే, if expression ట్రూ అయితే ఓ statement గ్రూప్ ను, లేకపోతే వేరేవాటిని రన్ చేస్తాం). దీనిని అంతగా వాడరు. దీని ద్వారా ప్రోగ్రాం executionను ఒక దగ్గర నుంచి ఇంకో దగ్గరకు మార్చేందుకు వీలు అవుతుంది. దీనికి లేబిల్ ను argument లాగా వాడతారు. ఈ క్రింద ఇచ్చిన ప్రోగ్రాంలో if, goto వాడుకొని ఒక statements గ్రూప్ ను ఎలా రిపీటడ్ గా execute చెయ్యాలో చూపిస్తున్నాం.

Example 6: ఈ ప్రోగ్రాం goto వాడి n students యావరేజ్ ఎలా కనుక్కొవాలో చూపిస్తుంది. ముఖ్యంగా, ఈ క్రింద ఇచ్చిన ప్రోగ్రాంలో if, goto వాడుకొని ఒక statements గ్రూప్ ను ఎలా రిపీటడ్ గా execute చెయ్యాలో చూపిస్తున్నాం. దీనినే if-goto loop అంటారు. ఇక్కడ ముందుగా, ఎంత మంది స్టూడెంట్ లో రీడ్ చేస్తాము (n). తర్వాత, i అనే variableకు సున్నా ఇచ్చి, ఒక student మార్క్స్ రీడ్ చేసినప్పుడల్లా దీనిని ఒకటి పెంచుతాం. దీని వాల్యూ కనుక n కన్నా తక్కువ అయితే మరలా ఇంకో student మార్క్స్ రీడ్ చేస్తాం. ఈ విధంగా అందరి మార్కులను రీడ్ చేసి అప్పుడు యావరేజ్ కనుక్కొంటాము. రీడ్ చేసిన ప్రతీ వాల్యూను s అనే variable కు కలుపుతాం. అలా టోటల్ వస్తుంది. దీనితో యావరేజ్ కనుక్కొంటాము. కింది ప్రోగ్రాం దీనిని వాడుకొని పని చేస్తుంది.
#include
int main()
{
int n, i, m, s ;
printf(“Enter number of students”);
scanf(“%d”, &n);
s=0;
i=0;

LOOPBEGIN: /*(It is a Label)*/
scanf(“%d”, &m);
s = s + m;
i ++;
if(i

printf(“%d, %d\n”, s, s/n);
return (0);
}

ఈ కింద ఇచ్చిన టేబుల్, పై ప్రోగ్రాం ఎలా పని చేస్తుందో విశదీకరిస్తుంది. ఒక ప్రోగ్రాం ఎలా పని చేస్తుందో తెలుసుకోవచ్చు.ఇలా చేయడాన్ని simulation అంటారు.

పైన ఇచ్చిన ప్రోగ్రామును రన్ చేసినప్పుదు కంప్యూటరు మీద ఇలా వుంటుంది.

4. SWITCH CONSTRUCT

ఇది ఇంకో C లాంగ్వేజ్ control structure. దీనిలో ఒక expression, ఆ expression యొక్క వాల్యూ ఎంత అయినప్పుడు ఏం చెయ్యాలో చెప్పే ( వీటినే cases అని అంటారు) statements ఈ కింద విధంగా ఉంటాయి. అంటే ప్రోగ్రాం రన్ అవుతున్నప్పుడు, EXPR వాల్యూ 0 అయితే case 0: తర్వాత వుండే statements ( next break వుండేవి) రన్ అవుతాయి. అదే, EXPR వాల్యూ 1 అయితే case 1: తర్వాత వు0డే statements ( next break వు0డేవి) రన్ అవుతాయి. అదే, EXPR వాల్యూ 2 అయితే case 2: తర్వాత ఉండే statements ( next break ఉండేవి) రన్ అవుతాయి. అలా కాకుండా, EXPR వాల్యూఇంకేదయినా అయితే, default: తర్వాత ఉండే statements ( next break ఉండేవి) రన్ అవుతాయి. దీనినే default clause అని అంటారు. ఈ default clause లేకుండా కూడా switch constructను రాయవచ్చు. ఈ switch construct రాసేటవ్పుడు, case అనే word తర్వాత integer constants, character constantsను మాత్రమే వాడాలి.

Example 7: ఈ ప్రోగ్రాం ఒక student marks రీడ్ చేసి పాసో, ఫెయిలో ప్రింట్ ఛేస్తుంది. ఇది ఇంతకు ముందు if-elseలు వాడి రాసిందే. కానీ ఇక్కడ, switch వాడి చేస్తున్నాము.

Solution: రీడ్ చేసిన student markను 35తో కంపేర్ చేసేది switchలో వాడుతున్న expression. ఇది 1 అయితే (అంటే పాస్ అయితే), case 1 తో మాచ్ అవుతుంది. కనుక తర్వాత ఉండే statements రన్ అవతాయి. లేకుంటే, case 0 తర్వాత వుండే statements రన్ అవతాయి. ఉదాహరణకు, 75 ఇస్తే case 1 తో మాచ్ అవుతుంది. కనుక case 1 తర్వాత ఉండే statements రన్ అవతాయి, 25 ఇస్తే case 0 తర్వాత ఉండే statements రన్ అవతాయి.
#include
int main()
{
int n;
printf(“Enter a student mark”);
scanf(“%d”, &n);

switch (n>=35){
case 0:
printf(“Failed\n”);
break;
case 1:
printf(“Passed\n”);
break;
}
return (0);
}
పైన ఇచ్చిన ప్రోగ్రామును రన్ చేసినప్పుదు కంప్యూటరు మీద ఇలా వుంటుంది.

Example 8: ఒక student కు వచ్చిన test marks రీడ్ చేసి ఈ కింద ఇచ్చిన వాటిలో ఎదో ఒక మెసేజి ప్రింట్ చెయ్యలి.
First Class
Second Class
Third Class
Failed
Solution: ముందు ఒక switchని వాడుతూ marksను 35 తో కంపేర్ చేస్తాం. పాస్ అయితే (case 1), ఇంకో switch వాడి Class డిసైడ్ చేస్తాం. రెండో switchలో expressionను n/10 గా వాడాము. ఈ కింది టేబిల్, marks ఎంత వుంటే n/10 ఎంత చూపిస్తుంది అనే దానిని చూపిస్తుంది. దీనిపై ఆధారపడి, switch case లను design చేశాము.

#include
int main()
{
int n;
printf(“Enter a student mark\n”);
scanf(“%d”, &n);
switch (n>=35){
case 0:
printf(“Failed\n”);
break;
case 1:
switch(n/10){
case 3:
case 4: printf(“Third Class\n”);
break;
case 5: printf(“Second Class\n”);
break;
default: printf(“First Class\n”);
break;
}
break;
}
return (0);
}
పైన ఇచ్చిన ప్రోగ్రామును రన్ చేసినప్పుదు కంప్యూటరు మీద ఇలా వుంటుంది.

ఇక్కడ case 3, case 4లలో ఒకే statements అనగా printf(“Third Class\n”);, రన్ అవుతాయి. ఇలాగా case లను గ్రూప్ చెయ్యవచ్చు. అనగా n/10 వాల్యూ 3 అయినా 4 అయినా సేమ్ పని చేస్తుంది.
Example 9: ఈ ప్రోగ్రాం ఒక characterను రీడ్ చేసి అది Vowel అవునా కాదా అని ప్రింట్ చేస్తుంది.
Solution: ఒక characterను v అనే variable లోకి రీడ్ చేసి దానిని switch expression లా వాడుతున్నాం. అది కనుక ‘A’, ‘E’, ‘I’, ‘O’, ‘U’, ‘a’, ‘e’, ‘i’, ‘o’, ‘u’, లలో ఏదో ఒకటి అయితే vowel అని లేకుంటే కాదని ప్రింట్ చేస్తున్నాం.

#include
int main()
{
char v;
printf(“Enter an alphabet\n”);
scanf(“%c”, &v);
switch (v){
case ‘A’:
case ‘E’:
case ‘I’:
case ‘O’:
case ‘U’:
case ‘a’:
case ‘e’:
case ‘i’:
case ‘o’:
case ‘u’: printf(“Vowel\n”);
break;
default: printf(“Not Vowel\n”); break;
}
return (0);
}
పైన ఇచ్చిన ప్రోగ్రామును రన్ చేసినప్పుదు కంప్యూటరు మీద ఇలా వుంటుంది.

ఈ కింద కొద్ది మార్పుతో మరో ప్రోగ్రాంను చేసాం. ఇక్కడ ముందుగా రీడ్ చేసిన దానిని అప్పర్ లోకి మార్చి, ‘A’, ‘E’, ‘I’, ‘O’, ‘U’, మాత్రమే మ్యాచ్ చేస్తున్నాం. కావున ఐదు కేస్ లు మాత్రమే ఇక్కడ వాడాం .
#include
#include
int main()
{
char v;
printf(“Enter an alphabet”);
scanf(“%c”, &v);
switch (toupper(v)){
case ‘A’:
case ‘E’:
case ‘I’:
case ‘O’:
case ‘U’: printf(“Vowel\n”);
break;
default: printf(“Not Vowel\n”);
break;
}
return (0);
}

Example 10: ఈ కింది ప్రోగ్రాం రెండు వాల్యూస్ ను, మరియు operatorను రీడ్ చేసి, ఆ operator ను operands మధ్యలో అప్లై చేసి రిజల్ట్ ప్రింట్ చేస్తుంది.
#include
int main( )
{
double n1, n2, res;
char op;

printf("Please enter real numbers: ");
scanf("%lf%lf", &n1, &n2);

printf("Please enter an arithmetical operator (+, -, * or /): ");
scanf(" %c", &op);

switch(op) {
case '+':
res = n1+n2;
break;
case '-':
res = n1-n2;
break;
case '*':
res = n1*n2;
break;
case '/': /* We're not checking for division by zero for clarity... */
res = n1/n2;
break;
default:
printf("%c is an invalid arithmetical operator!\n", op);
return 1;
}

printf("%g %c %g = %g\n", n1, op, n2, res);
return 0;
}
పైన ఇచ్చిన ప్రోగ్రామును రన్ చేసినప్పుదు కంప్యూటరు మీద ఇలా వుంటుంది.

5. Conclusions