25. सीखिए सी : continue, break और exit निर्देश

पिछले अध्याय में हमने while, do... while और for लूपों की चर्चा की और देखा कि किस प्रकार इन लूप संरचनाओं के उपयोग से हम प्रोग्राम की कुछ उक्तियों का निष्पादन बारबार करा सकते हैं। इन उक्तियों का आवर्तन तब तक चलता रहता है जब तक इनके गोल कोष्ठकों में विद्यमान तार्किक व्यंजक का मान 0 नहीं हो जाता।

लेकिन अनेक बार इन लूपों के तार्किक व्यंजक का मान 0 होने से पहले ही लूप से छूटना जरूरी होता है, क्योंकि तब तक प्रोग्राम का उद्देश्य सिद्ध हो चुका होता है, या उपयोगकर्ता प्रोग्राम से बाहर आना चाहता है। सी भाषा में इन स्थितियों से निपटने के लिए तीन निर्देश हैं, continue, break और exit।

इस तिकड़ी का सबसे नरम मिजाज वाला निर्देश continue निर्देश है। यदि किसी while वलय में प्रोग्राम नियंत्रण का सामना इस निर्देश से हो जाए, तो नियंत्रण तुरंत लूप के वर्तमान आवर्तन को त्यागकर लूप के तार्किक व्यंजक का पुनः परीक्षण करने चला जाता है, और यदि उसका मान 1 रहा तो वलय का एक नया आवर्तन आरंभ कर देता है।

break निर्देश continue से कुछ अधिक तेज-तर्रार है। किसी लूप वलय के भीतर इस निर्देश का सामना होने पर प्रोग्राम लूप तोड़ देता है, तथा लूप के बाद के निर्देशों का निष्पादन करने लगता है, भले ही लूप के तार्किक व्यंजक का मान अब भी 1 क्यों न हो।

तीसरा निर्देश exit है, जो सबसे अधिक उग्र स्वभाव का है, क्योंकि वह न केवल लूप को तोड़ देता है, बल्कि समस्त प्रोग्राम को ही खारिज कर देता है और आप वापस प्रचालन तंत्र में आ जाते हैं।

आइए इन लूप-भंजक तिकड़ियों का परिचय कुछ सरल प्रोग्रामों के माध्यम से प्राप्त करें।

प्रथम प्रोग्राम में 8 के 5 गुणजों का पता लगाया जाता है और जब पांच गुणज मिल जाते हैं, तब break निर्देश की सहायता से while लूप को तोड़ा जाता है।

प्रोग्राम – 21
---------------------------------
/*break nirdesh ka udaharan */

#include <stdio.h>
#include <conio.h>


void main()
{
clrscr();

int ganak=0;
int soochak=1;
while(1)
{
printf("%d ", 8*soochak);
soochak++;
ganak++;
if (ganak >= 5)
break;
}
getch();
}
---------------------------------

आउटपुट
---------------------------------
8 16 24 32 40
---------------------------------
इस प्रोग्राम में दो पूर्णांक राशियां घोषित की गई हैं, ganak और soochak। ganak को 0 और soochak को 1 का मान दिया गया है। while वलय के गोल कोष्ठकों में आप इस बार 1 संख्या देखकर कुछ हैरान हुए होंगे। यह 1 वहां इसलिए है क्योंकि हम वलय से निकलने के लिए while वलय के तार्किक व्यंजक के मान के 0 होने पर नहीं, बल्कि उसके धनु कोष्ठकों के भीतर छिपे break निर्देश पर निर्भर हैं। हम चाहते हैं कि while वलय तब तक चलता रहे जब तक यह break निर्देश उसे तोड़ न दे। इसके लिए हर स्थिति में while के कोष्ठकों का मान 1 होना जरूरी है। इसीलिए while के गोल कोष्ठकों में 1 रखा गया है।

while के भीतर पहली उक्ति printf() वाली है, जो 8 और soochak के वर्तमान मान के गुणनफल को स्क्रीन पर छापती है। ध्यान दें कि printf() के दुहरे उद्धरण चिह्नों के बाद %d के बाद एक रिक्त स्थान भी है, ताकि अगला अंक पहले अंक से बिलकुल सटकर न छपे और दोनों के बीच दूरी रहे। चूंकि प्रथम आवृत्ति पर soochak का मान 1 है, इसलिए स्क्रीन पर 8 और एक खाली जगह छपेगा।

इसके बाद दो इंक्रिमेंट निर्देश हैं जो क्रमशः soochak के मान को 2 और ganak के मान को 1 बना देते हैं। यह ganak ही वह राशि है, जो छपे हुए गुणजों की गिनती रखता है। इसके बाद if वाली उक्ति है, जो ganak के मान को 5 से तुलना करके देखता है, और उसके नीचे के break निर्देश का निष्पादन तभी होता है जब ganak का मान 5 से अधिक हो जाए।

अभी, चूंकि ganak का मान 1 है, जो 5 से कम है, if के निर्देशों का निष्पादन नहीं होता, और प्रोग्राम का नियंत्रण वापिस while उक्ति को लौट जाता है। यहां चूंकि कोष्ठकों में 1 है, नियंत्रण while की उक्तियों का निष्पादन करने लगता है और स्क्रीन पर 8 का अगला गुणज छपता है।

इस प्रकार पांच आवृत्तियां होती हैं, और तब if का तार्किक व्यंजक का मान 1 हो जाता है, क्योंकि अब ganak का मान 5 हो गया है। इसलिए ganak >= 5 व्यंजन का मान 1 हो जाता है और if की break वाली उक्ति का निष्पादन होता है। यह वलय को तोड़ देता है और नियंत्रण प्रोग्राम की अलगी उक्ति की ओर बढ़ता है, जो है return (0); वाली उक्ति। इसलिए प्रोग्राम का समापन हो जाता है।

इस उदाहरण में मामूली सा परिवर्तन करने पर वह exit निर्देश का एक अच्छा उदाहरण हो सकता है। इन परिवर्तनों के साथ उपर्युक्त प्रोग्राम नीचे दिया गया है। यहां break के स्थान पर exit (0) आया है।

प्रोग्राम – 22
---------------------------------
/*exit nirdesh ka udaharan */

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>

void main()
{
clrscr();

int ganak=0;
int soochak=1;
while(1)
{
printf("%d ", 8*soochak);
soochak++;
ganak++;
if (ganak >= 5)
exit(0);
}

getch();
}
---------------------------------

आउटपुट
---------------------------------
8 16 24 32 49
---------------------------------

अब आइए इस परिवर्तित प्रोग्राम को दखें। जब ganak का मान 5 हो जाता है और if निर्देश के अंतर्गत आया exit (0) निर्देश के निष्पादन की नौबत आती है, तो वह तुरंत ही प्रोग्राम के नियंत्रण को प्रचालन तंत्र को, यानी डॉस को, लौटा देता है। exit (0); निर्देश के बाद कोई भी निर्देश रखना व्यर्थ है, क्योंकि इन निर्देशों का कभी निष्पादन नहीं होता। इस प्रोग्राम के अंत में जो getch() वाला निर्देश है, उसका इसी कारण निष्पादन नहीं होता। exit (0) के कारणउस तक पहुंचने से पहले ही प्रोग्राम का अंत हो जाता है।

एक और बात ध्यान देने लायक है। exit (0) stdlib का फंक्शन इसलिए उसका उपयोग करने के लिए हमें stdlib के हेडर फाइल को अपने प्रोग्राम में include करना होगा। इसीलिए इस प्रोग्राम के शुरू में यह पंक्ति है –

#include <stdlib.h>

अंतिम उदाहरण एक साथ इन तीनों निर्देशों का उदाहरण है, पर आप विशेष ध्यान continue निर्देश के कार्य पर दीजिए। continue निर्देश प्रोग्राम के उपयोगकर्ताओं को अनुचित सूचनाएं टंकित करने से रोकने में बहुत उपयोगी है। नीचे दिए गए इस अध्याय के अंतिम प्रोग्राम में हम चाहते हैं कि प्रोग्राम में उपयोगकर्ता केवल 1 या 0 में से कोई अंक ही ऐंटर करे। 1 while की उक्तियों के निष्पादन के लिए, और 0 प्रोग्राम से बाहर निकलने के लिए।

इस प्रोग्राम में while की उक्तियों में एक साधारण-सी printf() उक्ति है, पर उसके स्थान पर कोई लंबा-चौड़ा कोड या उप-प्रोग्राम भी हो सकता है। यहां हमारा उद्देश्य continue, आदि निर्देशों के कार्य करने की रीति को दर्शाना मात्र है। यदि उपयोगकर्ता 1 या 0 से अलग कोई कुंजी दबाता है, तो प्रोग्राम continue निर्देश की सहायता से उसे उसकी गलती की सूचना देता है, और दुबारा कोशिश करने को कहता है।

प्रोग्राम – 23
---------------------------------
/*continue, break aur exit nirdesh ka udaharan */

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>

void main()
{
clrscr();

int vikalp;

printf("Kya aap aage badna chahte hai? 'Han' ke liye 1 aur 'na' ke liye 0 enter kijie: \n");
scanf("%d", &vikalp);
flushall();

while(1) {

if (vikalp != 1 && vikalp != 0)
{
printf("Aapne galat kunji dabai. Kripaya 1 ya 0 me se koi kunji dabaiye: \n");
scanf("%d", &vikalp);
continue;
}

if (vikalp == 1)
{
printf("Program me aapka swagat hai.\n");
break;
}

else if (vikalp == 0)
exit (0);
}
getch();
}
---------------------------------

आउटपुट
---------------------------------
Kya aap aage badna chahte hai? 'Han' ke liye 1 aur 'na' ke liye 0 enter kijie: 9
Aapne galat kunji dabai. Kripaya 1 ya 0 me se koi kunji dabaiye: 1
Program me aapka swagat hai.

Aapne galat kunji dabai. Kripaya 1 ya 0 me se koi kunji dabaiye: 0
(प्रोग्राम से आप बाहर आ जाते हैं।)

Aapne galat kunji dabai. Kripaya 1 ya 0 me se koi kunji dabaiye: 1
Program me aapka swagat hai.

Aapne galat kunji dabai. Kripaya 1 ya 0 me se koi kunji dabaiye:6
Aapne galat kunji dabai. Kripaya 1 ya 0 me se koi kunji dabaiye:
---------------------------------

इस प्रोग्राम में हमने प्रथम scanf() निर्देश के बाद flushall() का उपयोग किया है। यह इसलिए क्योंकि प्रोग्राम में आगे एक और scanf() कथन आता है, और यदि हम इनपुट स्ट्रीम को साफ न करें, उसमें रह गए ऐंटर कुंजी को दूसरा scanf() कथन पकड़ लेगा और उसे vikalp में रख देगा, जिससे हमारा प्रोग्राम ठीक से काम नहीं करेगा।

प्रथम if निर्देश के तार्किक व्यंजन पर भी ध्यान दें। वह है –

if (vikalp != 1 && vikalp != 0)

यहां दो तार्किक व्यंजक && (ऐंड अर्थात और) प्रचालक से जुड़े हुए हैं –

vikalp != 1
vikalp != 0

इसलिए इस तार्किक व्यंजक का मान तभी 1 बनेगा जब ये दोनों का मान 1 होगा। अन्य शब्दों में कहें, तो जब इनपुट 1 और 0 के अलावा कुछ होगा। जब ऐसा होता है, तो प्रोग्राम यह वाक्य प्रदर्शित करता है,

Aapne galat kunji dabai. Kripaya 1 ya 0 me se koi kunji dabaiye:

और इनपुट के लिए प्रतीक्षा करता है।

सीखिए सी - 24 : आवर्तन की संरचनाएं : for लूप

while और do... while लूपों में लूप के कोड़ खंड का कितनी बार आवर्तन होता है, यह निश्चित नहीं होता है। जब तक इनकी while उक्ति के गोल कोष्ठक में विद्यमान तार्किक व्यंजन का मान 1 होता है, कोड खंड का आवर्तन होता रहता है।

कई बार हमें इसकी आवश्यकता रहती है कि कोड खंड का आवर्तन पूर्वनिश्चित बार ही हो। इस तरह की आवश्यकताओं की पूर्ति हेतु सी में for लूप की व्यवस्था है, जो निश्चित बार आवर्तन करता है। यद्यपि for लूप निश्चित बार आवर्तन के लिए बना है, लेकिन वह अत्यंत लचीला है और उसे प्रोग्रामर while लूप के समान भी काम करा सकता है। लेकिन शुरुआत के लिए हम उसके मूल रूप से परिचय बढ़ाएं। for लूप का हुलिया इस प्रकार होता है:-

for (प्रारंभिक मान; शर्त; प्रारंभिक मान में वृद्धि)
{
उक्तियां;
}

ध्यान दें कि for लूप के गोल कोष्ठकों के बीच तीन उक्तियां हैं, जिन्हें दो अर्ध विरामें से अलग किया गया है। ये हैं:

• प्रारंभिक मान
• शर्त
• प्रारंभिक मान में वृद्धि

for लूप को चलाने के लिए सबसे पहले एक लूप गणक निश्चित किया जाता है, जो int (पूर्णांक) प्रकार की कोई राशि होती है। इसे कोई प्रारंभिक मान दिया जाता है, जो सामान्यतः 0 अथवा 1 होता है, पर कोई भी पूर्ण संख्या हो सकता है।

इसके बाद for लूप के आवर्तन के लिए आवश्यक कोई शर्त रखी जाती है। सामान्यतः यह लूप गणक का किसी उच्चतम मान से छोटा होना या बड़ा होना होता है, पर कोई भी अन्य शर्त भी हो सकती है। इतना ही नहीं, यहां एक से अधिक शर्त भी हो सकते हैं, जिन्हें एंड (&&) या ओर (||) प्रचालकों से जोड़ा जा सकता है। संकलक इन सभी शर्तों का एक साथ मूल्यांकन करेगा और उनका सम्मिलित तार्किक मान निर्धारित करेगा। यदि यह मान 1 निकले, तो लूप की उक्तियों का निष्पादन होगा, यदि 0 निकले, तो लूप टूट जाएगा और संकलक प्रोग्राम में लूप के बाद आनेवाली उक्तियों का निष्पादन करने लगेगा।

तीसरी उक्ति लूप गणक के मान में वृद्धि करनेवाली उक्ति होती है। हमने while loop के संबंध में बताया था कि while लूप के कोड खंड में ऐसी कोई उक्ति होनी चाहिए जो लूप के शर्त को बदले, अन्यथा while loop अनंत काल तक चलता रहेगा। for लूप में इस उक्ति को उसके कोड खंड में न रखकर स्वयं for लूप के गोल कोष्ठकों के अंदर अंत में रखा जाता है। ऊपर के पैरा में बताया गया था कि for लूप में अक्सर तार्किक व्यंजक के रूप में लूप गणक को किसी पूर्वनिश्चित मान से तुलना कराया जाता है और यदि लूप गणक इस मान से छोटा या बढ़ा हुआ, तो लूप टूट जाता है। इसके लिए यह आवश्यक है कि लूप के हर आवर्तन के बाद लूप गणक का मान घटे या बढ़े। इससे संबंधित उक्ति for लूप के गोल कोष्ठकों में विद्यमान अंतिम उक्ति में रहता है। यही वह उक्ति है जो for लूप के तार्किक व्यंजन (लूप तोड़नेवाली शर्त) के मान में परिवर्तन लाता रहता है, और एक निश्चित बार for लूप के आवर्त के बाद उस तार्किक व्यंजन के मान को 0 कर देता है, जिससे लूप टूट जाता है।

आइए एक वास्तविक उदाहरण से for लूप के कार्य करने को समझें। इस छोटे प्रोग्राम में एक for लूप की मदद से 1 से 5 तक की संख्याओं को मुद्रित किया जाता है।

प्रोग्राम – 20
---------------------------------
/*for loop ka udaharan */

#incldue <stdio.h>
#incldue <conio.h>


void main()
{
clrscr();

int ganak;
for (gank=1; x<=5;ganak++)
{
printf(“%d\n”, ganak);
}
getch();
}
---------------------------------

आउटपुट:
---------------------------------
1
2
3
4
5
---------------------------------

आइए इस प्रोग्राम को समझते हैं। इसमें सबसे पहले एक int प्रकार की राशि घोषित की गई है, जिसका नाम ganak रखा गया है।

इस ganak राशि को for लूप के गोल कोष्ठक की प्रथम उक्ति में 1 का मान दिया गया है। for लूप की तार्किक व्यंयन के रूप में यह शर्त रखी गई है कि ganak का मान 5 से कम या उसके बराबर होना चाहिए। इस सी उक्ति को देखिए, जिसमें यह बात कही गई है:-

ganak<=5;

for लूप की तीसरी उक्ति में ganak पर इंक्रिमेंट प्रचालक का प्रयोग किया गया है:-

ganak++

for लूप के कोड खंड में केवल एक उक्ति है, जो ganak के मान को printf () की मदद से अलग पंक्ति में स्क्रीन पर मुद्रित करता है।

for लूप के हर आवर्तन में ganak का मान 1 से बढ़ जाता है (ganak++ के कारण) और जब उसका मान 6 हो जाता है, तो लूप टूट जाता है।

for लूप के गोल कोष्ठकों में दो अर्धविरामों से अलगाए गए तीन कोड क्षेत्रों में से प्रत्येक में एक से अधिक उक्तियां भी हो सकती हैं, यथा,

for (int ganak1=0, int ganak2 =100; शर्त 1 && शर्त 2 || शर्त 3; ganak1++, ganak2--)

उपर्युक्त for लूप में दो गणक हैं ganak1 और ganak2 और तीन शर्ते हैं जो && और || से जुड़े हुए हैं। लूप के हर आवर्तन में ganak1 का मान 1 से बढ़ता जाता है, और ganak2 का मान 1 से घटता जाता है।

इस तरह से for लूप को अनेक वास्तविक परिस्थितियों में प्रयोग किया जा सकता है, और उसे while लूप की तरह भी काम कराया जा सकता है, इस तरह:-

for (;शर्त;)
{
उक्तियां;
}

इसमें for लूप के गोल कोष्ठकों में केवल एक क्षेत्र में कोड है, यानी शर्त वाले क्षेत्र में, बाकी दो में कोई उक्ति नहीं है। अर्ध विरामों का प्रयोग फिर भी हुआ है क्योंकि ये for लूप के वाक्य-विन्यास का आवश्यक अंग हैं। यह for लूप while loop के समान कार्य करेगा और जब तक शर्त का मान 1 हो, लूप चलता रहेगा। हां, उसके कोड खंड में ऐसी कोई उक्ति होनी चाहिए जो कभी न कभी शर्त को गलत बनाए, अन्यथा यह लूप निरंतर चलता जाएगा।

आप पूछ सकते हैं कि यदि for लूप से while लूप का काम भी लिया जा सकता है तो while लूप है ही क्यों, उसका आवश्यकता ही क्या है?

इसका जवाब यह है कि प्रोग्रामों का एक आवश्यक गुण यह होता है कि वे कम से कम समय में निष्पादित हों। इसलिए प्रोग्रामर हमेशा ऐसे कोड लिखने का प्रयत्न करते हैं जिसका निष्पादन ज्यादा तेजी से हो। जब आप सी को कुछ बेहतर रूप से समझने लगेंगे, आपको विदित होगा कि एक ही काम को करने के लिए सी में कोड कई तरह से लिखे जा सकते हैं। पर उनमें से कुछ प्रकार अधिक तेजी से निष्पादित होंगे, कुछ कम तेजी से, और साधारण प्रोग्रामर और गुरु प्रोग्रामर में यही अंतर होता है कि गुरु प्रोग्रामर हमेशा ऐसा कोड लिखेगा जो अधिक तेजी से निष्पादित हो।

तो while लूप की संरचना for लूप की तुलना में अधिक सरल है और कंप्यूटर while लूप को for लूप से अधिक तेजी से निष्पादित करता है। आपने देखा है कि for लूप के गोल कोष्ठकों में तीन कोड क्षेत्र और प्रत्येक में कई उक्तियां हो सकती है। इसलिए जब कंप्यूटर for लूप का निष्पादन करता है, तो लूप के हर आवर्तन में उसे इन सभी उक्तियों का मूल्यांकन करना पड़ता है। सी के कुछ बड़े और जटिल प्रोग्रामों में लूप वाले खंडों का आवर्तन सैकड़ों बार हो सकता है। इसलिए for लूप का निष्पदान while लूप की तुलना में उल्लेखनीय रूप से धीमा होता है।

तो ध्यान रखनेवाली बात यह है कि जब आवर्तन कितनी बार होगा यह ठीक से पता न हो, तो while लूप का प्रयोग करें, और जब यह पता हो कि ठीक कितनी बार लूप का आवर्तन होगा, तो for लूप का प्रयोग करें।

और यदि लूप को कोड खंड का निष्पादन प्रथम बार हर स्थिति में (लूप की शर्त गलत होने की स्थिति में भी) कराना आवश्यक हो, तो do... while लूप का प्रयोग करें।

सीखए सी - 23 : आवर्तन की संरचनाएं - do... while लूप

do... while लूप while लूप का ही एक रूप है। इसमें और while लूप में फर्क यह है कि जहां while लूप में लूप तोड़ने वाली शर्त शूरू में रहता है, do... while लूप में यह शर्त अंत में आता है, इस तरह:-

do
{
उक्तियां;
} while (शर्त);

do... while लूप में धनु कोष्ठकों के बीच कई उक्तियां हो सकती हैं। उनमें से एक उक्ति ऐसी भी होनी चाहिए जो लूप तोड़नेवाली शर्त को बदलती हो, वरना लूप अनंत समय तक चलता रहेगा।

while और do... while लूप की संरचना में एक अन्य अंतर यह है कि while लूप में गोल कोष्ठकों के बाद अर्ध विराम चिह्न (;) नहीं है, जबकि do... while लूप में गोल कोष्टकों के बाद अर्ध विराम चिह्न (;) होता है। यह एक महत्वपूर्ण अंतर है। यदि do... while लूप के अंत में अर्ध विराम चिह्न (;) न रखा जाए तो संकलक को पता नहीं चल पाएगा कि while (शर्त) do... while लूप का भाग है अथवा एक स्वतंत्र while लूप।

आइए एक उदाहरण से do... while लूप को समझते हैं।

प्रोग्राम – 19
---------------------------------
/*do... while ka udaharan */

#include <stdio.h>
#include <conio.h>

void main()
{
clrscr();

int vetan=0;
char santusht = 'n';

printf("\nKya aapko maloom hai ki computer jagt me vetan badana bahut saral hota hai? \n\nAapko keval apna vetan batana hai, baki sab computer sambhal lega. \n\nTo batayiye, aap ka vetan kya hai: ");
scanf("%d", &vetan);
flushall();

do
{
printf("\Ab aapka vetan hai %d. Kya aap is vetan se santusht hai? Han ke liye y aur na ke like n darj karen: ", vetan+500);
scanf ("%c", &santusht);
flushall();
vetan = vetan + 500;
}
while (santusht == 'n');

printf ("\nDhanyavad. Aasha hai ab aap achcha kaam karenge.");
getch();
}
---------------------------------

आउटपुट
---------------------------------
Kya aapko maloom hai ki computer jagt me vetan badana bahut saral hota hai?
Aapko keval apna vetan batana hai, baki sab computer sambhal lega.
To batayiye, aap ka vetan kya hai: 10000
Ab aapka vetan hai 10500. Kya aap is vetan se santusht hai? Han ke liye y aur na ke like n darj karen: n
Ab aapka vetan hai 11000. Kya aap is vetan se santusht hai? Han ke liye y aur na ke like n darj karen: y
Dhanyavad. Aasha hai ab aap achcha kaam karenge.
---------------------------------

इस प्रोग्राम में दो राशियां घोषित की गई हैं – vetan और santusht। पहली int प्रकार की राशि है, जिसे 0 का मान दिया गया है। दूसरी char प्रकार की राशि है, जिसे n का मान दिया गया है।

scanf के जरिए प्रयोक्ता के वेतना का पता लगाया जाता है और उसे vetan में संचित किया जाता है।

इसके बाद वाला कथन आपके लिए नया है, इसलिए इसके बारे में कुछ विस्तार से समझाते हैं। यह कथन है –

flushall();

यह stdio लाइब्रेरी का एक फंश्नन है। scanf एक जटिल फंक्शन है, जो कभी-कभी अवांछित परिणाम देता है। उसके द्वारा इनपुट किए गए राशि को ठीक से पकड़वाने के लिए कुछ तिकड़क करने पड़ते हैं। इस प्रोग्राम के उस printf कथन पर विचार कीजिए जिसमें प्रोग्राम चलानेवाले व्यक्ति से अपने वेतन का खुलासा करने को कहा गया है। इस कथन के बाद कंप्यूटर प्रयोक्ता द्वारा अपना वेतन इनपुट करने के लिए रुका रहता है। प्रयोक्ता कोई मान इनपुट करता है, जैसे 10000। उसके बाद यह सूचित करने के लिए कि उसने इनपुट कर दिया है, ऐंटर कुंजी को दबा देता है। अब कंप्यूटर के इनपुट स्ट्रीम में दो वर्ण जमा हो गए हैं, 10000 और ऐंटर कुंजी का वर्ण। इनमें से हमें केवल पहला इनपुट चाहिए। यदि दूसरा इनपुट, यानी ऐंटर, इनपुट स्ट्रीम में रह जाए, तो यह प्रोग्राम में आगे गड़बड़ी फैला सकता है क्योंकि अगली बार जब आप scanf का उपयोग करेंगे, तो वह इस ऐंटर वर्ण को पकड़ेगा क्योंकि यही इनपुट स्ट्रीम में सबसे आगे रहेगा। इस अवांछित स्थिति से बचने के लिए हर बार scanf का उपयोग करने के बाद इनपुट स्ट्रीम को खाली करना जरूरी है। flushall() वाला फंक्शन यही करता है, ताकि जब भी आप scanf का उपयोग करें, आपको प्रयोक्ता द्वारा किया गया इनपुट ही मिले न कि इनपुट स्ट्रीम में रह गया कोई फालतू का वर्ण।

तो इसे ध्यान में रखिए। scanf का उपयोग करने के बाद हमेशा flushall() का उपयोग करें। यदि किसी प्रोग्राम में scanf के कारण गलत परिणाम मिल रहे हों, तो scanf के बाद flushall(); कथन रखकर देखें। इससे आपका प्रोग्राम ठीक से चलने लगेगा।

ठीक है, अब हम प्रोग्राम – 19 की ओर लौटते हैं। इस flushall (); उक्ति के बाद do... while लूप का do वाला भाग आता है। इसके धनु कोष्ठकों में ये उक्तियां हैं –

{
printf("\Ab aapka vetan hai %d. Kya aap is vetan se santusht hai? Han ke liye y aur na ke like n darj karen: ", vetan+500);
scanf ("%c", &santusht);
flushall();
vetan = vetan + 500;
}

printf कथन आपके वेतन में 500 का इजाफा कर देता है। इसी कथन में आपसे यह भी पूछा जाता है कि क्या आप इस वेतन से संतुष्ट हैं?

इसके बाद, scanf आपके उत्तर को (n या y) santusht में सहेज लेता है। इसके बाद वही flushall() कथन है।

अंतिम पंक्ति में vetan को 500 से बढ़ा दिया जाता है।

इसके बाद do... while लूप का while वाला भाग आता है, जो यह है -

while (santusht == 'n');

यह साधारण while लूप के समान ही है, केवल एक अंतर है। इसके अंत में अर्ध विराम (;) है। यह महत्वपूर्ण है। यदि इसे छोड़ दिया जाए, तो do... while लूप ठीक से काम नहीं करेगा।

इस उक्ति पर पहुंचकर कंप्यूटर देखता है कि क्या santusht का मान n है? यदि n है, तो do की उक्तियों का आवर्तन करता है। यदि नहीं है, तो do... while लूप टूट जाता है, और प्रोग्राम में उसके बाद की उक्तियों का निष्पादन होता है। इस प्रोग्राम में do... while के बाद एक printf कथन है, जो प्रयोक्ता को धन्यवाद देता है। कंप्यूटर इसका निष्पादन कर देता है।

इस उदाहरण से आपको while और do... while लूप का अंतर स्पष्ट हो गया होगा। while लूप का प्रयोग सामान्य आवर्तन के लिए होता है। लेकिन यदि ऐसी कोई स्थिति हो जिसमें आवर्तन शुरू करने से पहले कुछ आवश्यक कोड पंक्तियों का निष्पादन जरूरी हो, तो do... while अधिक उपयुक्त है।

सीखए सी - 22 : अभ्यास 3 का हल

1.
प्रोग्राम -15
---------------------------------

/*Abhyas - 3 : 1 ka hal*/
#include <stdio.h>
#include <conio.h>

void main()
{
clrscr();
int sankhya=0;
while (sankhya < 5)
{
printf("\nJaihindi!");
sankhya++;
}
getch();
}
---------------------------------

आउटपुट
---------------------------------
Jaihindi!
Jaihindi!
Jaihindi!
Jaihindi!
Jaihindi!
---------------------------------

2.
प्रोग्राम – 16
---------------------------------
/*Abhyas - 3 : 2 - kisi sankhya ki gunan talika (pahada) */

#include <stdio.h>
#include <conio.h>

void main()
{
clrscr();

int sankhya=0;
int ganak=1;
printf("\nAap kis sankhya ki gunan talika (pahada) banvana chate hai?");
scanf("%d",&sankhya);

while (ganak <= 10)
{
printf("\n%d x %d = %d", ganak, sankhya, ganak*sankhya);
ganak++;
}
getch();
}
---------------------------------

आउटपुट
---------------------------------
Aap kis sankhya ki gunan talika (pahada) banvana chate hai? 6
1 x 6 = 6
2 x 6 = 12
3 x 6 = 18
4 x 6 = 24
5 x 6 = 30
6 x 6 = 36
7 x 6 = 42
8 x 6 = 48
9 x 6 = 54
10 x 6 = 60
---------------------------------

इस प्रोग्राम के printf वाली उक्ति पर विशेष ध्यान दीजिए। उसे यहां मैं दुबारा दे रहा हूं –

printf("\n%d x %d = %d", ganak, sankhya, ganak*sankhya);

इसमें तीन %d वाले अंश हैं। प्रथम दो तो ganak और sankhya का प्रतिनिधित्व करते हैं, लेकिन तीसरा %d द्वारा gank और sankhya के गुणनफल को प्रदर्शित किया जाता है। यह गुणनफल printf के गोल कोष्ठकों के भीतर ही निकाला जाता है, इस व्यंजक में –

ganak*sankhya

printf के बारे में यह एक नई बात आपने सीखी है। इस तरह के अनेक शोटकट सी में संभव हैं। जैसे-जैसे आप सी को बहतर रूप से जानने लगेंगे, इन शोटकटों से आप परिचित होते जाएंगे।

3.
प्रोग्राम – 17
---------------------------------
/*Abhyas - 3 : 3 - 1 se lekar 100 sankhyaon ka yog */

#include <stdio.h>
#include <conio.h>


void main()
{
clrscr();

int yog=0;
int sankhya=1;
int ganak=1;

while (ganak <= 100)
{
yog=yog+sankhya++;
ganak++;
}
printf("\n1 se lekar 100 tak ki sankhayon ka yog %d hai.", yog);
getch();
}

---------------------------------

आउटपुट
---------------------------------
1 se lekar 100 tak ki sankhyaon ka yog 5050 hai.
---------------------------------

इस प्रोग्राम की केंद्रीय उक्ति यह है –

yog=yog+sankhya++;

yog नामक राशि में 1 से लेकर 100 तक के अंकों का योग जमा किया जाता है। हर बार जब while लूप घूमता है, yog में एक प्राकृतिक संख्या (sankhya) जोड़ी जाती है। yog का प्रारंभिक मान 0 रखा गया है। while लूप के हर आवर्तन में उसके साथ sankhya का मान जोड़ा जाता है। लूप के प्रत्येक आवर्तन में sankhya का मान 1 से बढ़ाया जाता है, इस कथन द्वारा –

sankhya++;

लूप तब टूटता है जब गणक का मान 101 हो जाता है।

4.
प्रोग्राम – 18
---------------------------------
/*Abhyas - 3 : 4 - 1 se lekar kisi vanchit sankhya tak ki sankhyaon ka yog */

#include <stdio.h>
#include <conio.h>


void main()
{
clrscr();

int yog=0;
int sankhya=1;
int ganak=1;
int vanchitsankhya=0;
printf("\nAap 1 se lekar kitni tak ki sankhyaon ka yog janna chahte hai? ");
scanf("%d",&vanchitsankhya);

while (ganak <= vanchitsankhya)
{
yog=yog+sankhya++;
ganak++;
}
printf("\n1 se lekar %d tak ki sankhayon ka yog %d hai.", vanchitsankhya, yog);
getch();
}
---------------------------------

आउटपुट
---------------------------------
Aap 1 se lekar kitni tak ki sankhyaon ka yog janna chahte hai? 25
1 se lekar 25 tak ki sankhayon ka yog 325 hai.
---------------------------------

इस प्रोग्राम में पिछले प्रोग्राम के 100 वाली संख्या की जगह vanchitsankhya के मान का प्रयोग किया जाता है। vanchitsankhya का मान प्रोग्राम के निष्पादन के दौरान scanf के जरिए प्राप्त किया जाता है।

सीखए सी - 21 : आवर्तन की संरचनाएं - while लूप

कंप्यूटर की एक खासियत यह है कि वह निर्देशों के किसी खंड का निष्पादन अनेक बार कर सकता है। इसे संभव बनानेवाली संरचनाओं को लूपिंग संरचनाएं कहते हैं। सी में इस प्रकार की तीन संरचनाएं हैं - while, do... while, और for। इस लेख में हम केवल while लूप पर विचार करेंगे।

while लूप
while लूप का रूप इस प्रकार होता है:

while (तार्किक व्यंजक)
{
उक्तियां;
}

while शब्द के आगे के गोल कोष्ठकों में एक या अधिक तार्किक व्यंजक रहते हैं। इनका सम्मिलित मान प्रारंभ में 1 होता है। इसके बाद धनु कोष्ठकों के भीतर एक या अधिक उक्तियां होती हैं। उनमें से कोई एक उक्ति गोल कोष्ठक में मौजूद किसी राशि को परिवर्तित करनेवाली उक्ति होती है। कंप्यूटर इन उक्तियों का निष्पादन तब तक करता रहता है, जब तक कि while के गोल कोष्ठक के भीतर मौजूद तार्किक व्यंजक का मान 0 नहीं हो जाता। ध्यान रहे कि तार्किक व्यंजकों के केवल दो मान हो सकते हैं, 0 या 1।

नीचे के प्रोग्राम में while वलय का उपयोग करते हुए 10 पंक्तियां मुद्रित की जाती हैं। प्रत्येक पंक्ति में उस पंक्ति की क्रम-संख्या भी छपती है।

प्रोग्राम-12
---------------------------------
/*while loop ka udaharan */

#include <stdio.h>
#include <conio.h>

void main()
{
clrscr();

int kram_sankhya=1;

while(kram_sankhya < 11)
{
printf("Yah pankti no. %d hai.\n", kram_sankhya);
kram_sankhya++;
}

getch();
}
---------------------------------

आउटपुट:
---------------------------------
Yah pankti no. 1 hai.
Yah pankti no. 2 hai.
Yah pankti no. 3 hai.
Yah pankti no. 4 hai.
Yah pankti no. 5 hai.
Yah pankti no. 6 hai.
Yah pankti no. 7 hai.
Yah pankti no. 8 hai.
Yah pankti no. 9 hai.
Yah pankti no. 10 hai.
---------------------------------

इस प्रोग्राम में सबसे पहले kram_sankhya नामक पूर्णांक राशि घोषित की गई है और उसे 1 का मान दिया गया है। तत्पश्चात while वलय शुरू होता है। उसके कोष्ठकों में एक तार्किक व्यंजक है, जो इस प्रकार है:

kram_sankya <11

इस तार्किक व्यंजक का मान 1 तब तक रहता है, जब तक kram_sankhya का मान 11 या उससे बड़ा नहीं हो जाता। फिलहाल उसका मान 1 है, क्योंकि हमने उसे प्रोग्राम के शुरू में यही मान दिया है। चूंकि यह मान 11 से कम है, उपर्युक्त तार्किक व्यंजन का मान भी 1 है।

इसके बाद धनु कोष्ठकों में वे उक्तियां हैं, जिन्हें बार-बार दुहराना है। हमारे इस छोटे से प्रोग्राम में ऐसी केवल दो उक्तियां ही हैं। पहली उक्ति में printf() का आह्वान है। यह एक संदेश के भीतर एक पूर्णांक राशि को छापता है। यह पूर्णांक राशि kram_sankhya है। शुरू में इसका मान 1 है, इसलिए printf() यह वाक्य छापता है:

Yah pankti no. 1 hai.

चूंकि संदेश के अंत में \n है, printf() उपर्युक्त पंक्ति के बाद एक नई पंक्ति शुरू कर देता है, यानी कर्सर अलगी पंक्ति के शुरू में चला जाता है।

प्रोग्राम की अगली उक्ति में kram_sankhya राशि पर इंक्रिमेंट प्रचालक ++ का प्रयोग हुआ है, जो kram_sankhya के मान को 1 से बढ़ा देता है, यानी 2 कर देता है। इसके बाद कोई और उक्ति नहीं है, इसलिए प्रोग्राम का नियंत्रण एक बार फिर while वलय के प्रारंभिक पंक्ति को लौटकर तार्किक व्यंजन का एक बार फिर परीक्षण करता है। चूंकि 2, 11 से छोटा है, इसलिए while के तार्किक व्यंजन का मान अब भी 1 बना हुआ है और प्रोग्राम नियंत्रण while वलय की उक्तियों की ओर बढ़ जाता है।

यह क्रम दस बार चलता है और हर बार इंक्रिमेंट प्रचालक kram_sankhya का मान 1 से बढ़ाता जाता है। दसवीं बर इंक्रिमेंट प्रचालक kram_sankhya का मान 11 कर देता है। इसके बाद जब प्रोग्राम का नियंत्रण while के प्रारंभ में जाकर तार्किक व्यंजन की समीक्षा करता है, तो पाता है कि अब तार्किक व्यंजक का मान 0 हो गया है, क्योंकि 11, 11 से छोटा नहीं है। अतः प्रोग्राम नियंत्रण वलय के भीतर नहीं घुसता और वलय के बाद वाली उक्ति की ओर बढ़ जाता है।

चूंकि वहां और कोई उक्ति नहीं है, इसलिए प्रोग्राम का समापन हो जाता है।

अब हम while वलय का उपयोग करते समय ध्यान में रखनेवाली दो बातों का उल्लेख करेंगे। ये हैं:

1. while वलय के कोष्ठकों में जिस राशि का परीक्षण होता है, उसे while वलय के पूर्व कोई प्रारंभिक मान देना जरूरी है। इस उदाहरण में यह राशि kram_sankhya है, और उसे 1 का मान दिया गया है।

2. धनु कोष्ठकों में मौजूद कोई एक उक्ति को इस राशि के मान में कोई परिवर्तन लाना चाहिए, तभी while वलय का समापन होगा। इस प्रोग्राम में इंक्रिमेंट प्रचालक kram_sankhya के मान को 1 से बढ़ाता जाता है, जिससे दसवीं आवृत्ति पर वह 11 का मान प्राप्त कर लेता है, जिससे while का तार्किक व्यंजन का मान 0 हो जाता है, और वलय टूट जाता है। यदि आप इस इंक्रिमेंट उक्ति को छोड़ देंगे, तो kram_sankhya का मान 1 पर ही निर्विकार बना रहेगा और while वलय बड़े मजे से अनंत काल तक घूमता रहेगा। इस अनंत वलय से पीछा छुड़ाना आपके लिए मुश्किल हो जाएगा। आपके प्रोग्रामों में इस प्रकार की अप्रिय स्थितियों से बचने के लिए while वलय का उपयोग करते समय ऊपर कही गई दोनों बातों पर गांठ बांध लीजिए।

आइए एक और उदाहरण देखें:

प्रोग्राम-13
---------------------------------
/*while loop ka ek aur udaharan */

#include <stdio.h>
#include <conio.h>

void main()
{

clrscr();

int kram_sankhya=10;


printf("\nUlti ginti shuru!!!");

while (kram_sankhya>=0)
{

printf("\n%d", kram_sankhya);
kram_sankhya--;
}

printf("\n\nYan ke rocket dago!\n");
getch();
}
---------------------------------

आउटपुट
---------------------------------
Ulti ginti shuru!!!
10
9
8
7
6
5
4
3
2
1
0
Yaan ke rocket dago!
---------------------------------

यह प्रोग्राम किसी रोकेट यान के उड़ान भरने के पहले की उल्टी गिनती का निर्दशन करता है।

यहां kram_sankhya को 10 का प्रारंभिक मान दिया गया है। while के तार्किक व्यंजक में इस बात का परीक्षण होता है कि kram_sankhya का मान 0 से बड़ा या उसके बराबर है, या नहीं। while के धनु कोष्ठकों में डिक्रिमेंट प्रचालक kram_sankhya के मान को हर आवृत्ति के दौरान 1 से कम करता जाता है, जिससे दसवीं आवृत्ति के अंत में उसका मान ऋणात्मक हो जाता है, यानी 0 से कम, और इस कारण से तार्किक व्यंजन का मान 0 हो जाता है, और while वलय बिखर जाता है।

लीजिए एक और उदाहरण। यह गणित के छात्रों के लिए काम का हो सकता है, क्योंकि इसमें किसी संख्या का क्रमगुणित (फैक्टोरियल) ज्ञात किया जाता है। किसी संख्या का क्रमगुणित वह संख्या है जो उस संख्या तथा उसके पहले के सभी धनात्मक पूर्ण संख्याओं को आपस में गुणा करने पर प्राप्त होता है। उदाहरण के लिए 5 का क्रमगुणित होगा 5 x 4 x 3 x 2 x 1 = 120

प्रोग्राम-14
---------------------------------
/*while loop ki madat se kramganit (factorial) ka parikalan*/

#include <stdio.h>
#include <conio.h>


void main()
{
clrscr();

int sankhya, sankhyadharak;
long kramgunit;

printf("25 se chota koi ek dhanatmak sankhya enter kijiye: \n");
scanf("%d", &sankhya);
sankhyadharak = sankhya;
kramgunit = 1;

while (sankhya > 1)
{
kramgunit = kramgunit * sankhya;
sankhya--;
}

printf ("%d ka kramgunit %ld hai.\n", sankhyadharak, kramgunit);
getch();
}
---------------------------------

आउटपुट
---------------------------------
25 se chota koi ek dhanatmak sankhya enter kijiye: 6
6 ka kramgunit 720 hai.
---------------------------------

यहां दो पूर्णांक राशियां घोषित की गई हैं, sankhya और sankhyadharak और एक long प्रकार की राशि kramgunit । kramgunit के लिए long प्रकार चुनना इसलिए आवश्यक है क्योंकि क्रमगुणित संख्याएं बहुत बड़ी-बड़ी संख्याएं होती हैं, और वे साधारण int राशियों में नहीं समाएंगी। उदाहरण के लिए यदि आप kramgunit को int प्रकार की राशि घोषित करें, तो आपका प्रोग्राम 7 से अधिक संख्याओं के लिए काम नहीं करेगा। आपको kramgunit के रूप में कोई ऋणात्मक संख्या प्राप्त होगी। यह इसलिए क्योंकि int प्रकार की राशि में 36,000 से अधिक बड़ी संख्याएं नहीं समा सकतीं। यद्यपि long राशि में int राशि से कहीं बड़ी संख्याएं समा सकती हैं, फिर भी उसकी भी एक सीमा है, जिससे बड़ी संख्याएं उसमें नहीं समाएंगी। यदि आप इस प्रोग्राम में sankhya के लिए कोई बड़ी संख्या दें, जैसे, 100, तो यह प्रोग्राम सही परिणाम नहीं देगा। इसलिए प्रोग्राम लिखते समय प्रोग्राम में घोषित राशियों की सीमाओं का खास ध्यान रखना जरूरी होता है। इस प्रोग्राम में हमने सूचित किया है कि जो संख्या दर्ज की जाए, वह 25 से छोटा हो।

आइए देखें कि यह प्रोग्राम कैसे काम करता है। चूंकि while वलय में डिक्रिमेंट प्रचालक sankhya के मान को बदलता है, इसलिए उसके प्रारंभिक मान को बचाकर रखने की आवश्यकता है, क्योंकि हम अंतिम printf() उक्ति में मूल संख्या को प्रदर्शित करना चाहते हैं। अतः sankhya के प्रारंभिक मान को sankhyadharak में आरोपित किया गया है।

ध्यान दीजिए कि kramgunit को while वलय के पहले 1 का मान दिया गया है। यह इसलिए क्योंकि while वलय में kramgunit की गणना करने के लिए kramgunit को sankhya के वर्तमान मान से गुणन किया जाता है। चूंकि किसी संख्या को 1 से गुणन करने पर उसका मान नहीं बदलता, इसलिए while वलय के प्रथम बार निष्पादित होने पर जब sankhya को kramgunit से गुणन किया जाता है, तो प्रोग्राम का अंतिम परिणाम प्रभावित नहीं होता।

while वलय के कोष्ठकों में वलय की हर आवृत्ति के पहले sankhya के मान का परीक्षण होता है और यह देखा जाता है कि वह 1 से बड़ा है या नहीं। वलय के धनु कोष्ठकों की उक्तियों का निष्पादन तभी होता है, जब sankhya का मान 1 से बड़ा होता है। धनु कोष्ठकों की उक्तियों में से डिक्रिमेंट वाला प्रचालक sankhya के मान को वलय की हर आवृत्ति पर 1 से घटाता जाता है, जिससे वलय अनंत वलय होने से बच जाता है।

ध्यान दीजिए कि आउटपुट प्रिंट करने वाले printf कथन में हमें दूसरी संख्या के लिए %ld निरूपण चिह्न का प्रयोग किया है। यह इसलिए क्योंकि हमने इस दूसरी संख्या को, यानी kramgunit को long प्रकार की राशि घोषित किया है, और printf में long प्रकार की राशियों के लिए निरूपण चिह्न %ld ही होता है।

अभ्यास -3
1. while वलय का उपयोग करते हुए "Jai Hindi!" संदेश की आवृत्ति पांच बार करवाइए।

2. while वलय की सहायता से किसी संख्या की गुणन तालिका (पहाड़ा) दर्शाइए। उदाहरण के लिए 3 का पहाड़ा इस प्रकार होगा:

1 x 3 = 3
2 x 3 = 6
3 x 3 = 9
...
...
10 x 3 = 30

3. while वलय की सहायता से 1 से लेकर 100 तक के पूर्णांकों का सम्मिलित योग ज्ञात कीजिए।

4. प्रश्न 3 में इस प्रकार की तब्दीली कीजिए कि 100 के बजाए n संख्याओं का कुल योग ज्ञात हो। इस n का मान scanf() के जरिए प्रोग्राम के निष्पादन के दौरान प्राप्त किया जाए।

सीखिए सी - 20 : सशर्त कथन ___ ?___ : ___

अभ्यास – 2 का हल

प्रोग्राम – 10
--------------------------------
/*Abhyas 2 ka hal */

#include <stdio.h>
#include <conio.h>

void main()
{

clrscr();

float praptank;

printf("Batayiye, pariksha me kitne ank aaye: ");
scanf("%f", &praptank);
if(praptank >= 60)
{
printf("\nFirst Division.");
}

else if (praptank >=50)
{
printf("\nSecond Division.");
}
else if(praptank >=40)
{
printf("\nThird Division.");
}
else
{
printf("\nFail.");
}
getch();
}
-------------------------------


आउटपुट
-------------------------------
Batayiye, pariksha me kitne ank aaye: 65
First Division.
Batayiye, pariksha me kitne ank aaye: 54
Second Division.
Batayiye, pariksha me kitne ank aaye: 45
Third Division
Batayiye, pariksha me kitne ank aaye: 35
Fail.
-------------------------------

अब आपने सीख लिया है कि सी प्राग्रामों में if ... else संरचना की मदद से किस तरह विशाखन को अंजाम दिया जाता है।

सी में विशाखन लाने के कुछ अन्य तरीके भी हैं, यथा ? प्रचालक और switch संरचना। इनमें से ? प्रचालक, जिसे सशर्त कथन (conditional statement) कहा जाता है, अधिक सरल है, और उसका विवेचन हम इस लेख में करेंगे। switch संरचना को ठीक से समझने के लिए continue, break और exit कथनों की थोड़ी जानकारी प्राप्त करना आवश्यक है। इन कथनों की जानकारी हम आवर्तन के बारे में सीखने के बाद प्राप्त करेंगे, और उसके बाद switch को भी समझेंगे।

? प्रचालक का रूप इस तरह होता है।

तार्किक कथन ? व्यंजक 1 : व्यंजक 2

यानी, इसके तीन भाग होते हैं, जिन्हें ? और : द्वारा अलगाया हुआ होता है।

पहला भाग एक तार्किक व्यंजक होता है, जिसका मूल्यांकन पहले होता है और इसके परिणाम स्वरूप सही (1) या गलत (0) का मान प्राप्त होता है। तार्किक कथन के मूल्यांकन से यदि सही का मान आए, तो व्यंजक 1 में विद्यमान मान प्राप्त होता है, और यदि गलत का मान आए, तो व्यंजक 2 का मान होता है।

स्पष्ट ही सशर्त कथनों के प्रयोग से केवल दो विकल्पों को संभाला जा सकता है। दो से अधिक विकल्प होने पर if... else अथवा switch कथनों का सहारा लेना अनिवार्य हो जाता है।

आइए, सशर्त कथनों को एक प्रोग्राम के जरिए समझते हैं।

प्रोग्राम -11
-------------------------------
/* ? prachalak (conditonal statement) ka udaharan */

#include <stdio.h>
#include <conio.h>

void main()
{
clrscr();

float praptank;
char parinaam;

printf("\nPariksha me kitne ank aaye: ");
scanf("%f", &praptank);

result = (praptank>=40) ? 'P' : 'F';

printf("\nParinaam: %c", result);

getch();
}
-------------------------------

आउटपुट
-------------------------------
Pariksha me kitne ank aaye: 56
Parinaam: P
Pariksha me kitne ank aaye: 34
Parinaam: F
-------------------------------

इस प्रोग्राम में दो राशियां घोषित की गई हैं, praptank जो float प्रकार की राशि है, और parinaam जो char प्रकार की राशि है। scanf के जरिए praptank में प्राप्तांक का मान जमा किया जाता है।

इसके बाद की पंक्ति को ध्यान पूर्वक देखिए। आपकी सुविधा के लिए उसे यहां दुबारा दिया जा रहा है –

result = (praptank>=40) ? 'P' : 'F';

इसमें ? प्रचालक का उपयोग किया गया है। क्या आप इस प्रचालक में विद्यमान तीन व्यंजकों को पहचान पाएं? वे हैं –
1. (praptank>=40)
2. 'P'
3. 'F'

प्रोग्राम की यह पंक्ति इस तरह से काम करती है –

सबसे पहले praptank >= 40 का मूल्यांकन किया जाता है। यदि praptank 40 या उससे बड़ा हुआ, तो इस व्यंजनक को 1 का मान मिलता है, यानी यह व्यंजन सही ठहरता है। यदि praptank 40 से कम हुआ, तो इस व्यंजक को 0 का मान मिलता है, यानी यह व्यंजक गलत ठहरता है। यदि praptank >= 40 का मान 1 हो, तो result में P मान रख दिया जाता है। यदि praptank >= 40 का मान 0 हो, तो result में F मान रख दिया जाता है।

सशर्त कथन, यानी ? प्रचालक हमेशा कोई एक मान लौटाता है। यदि उसकी प्रथम उक्ति का मान 1 है, तो वह ? के बाद वाला मान लौटाता है, और यदि प्रथम उक्ति का मान 0 है, तो : के बाद वाला मान। इस मान को किसी राशि में पकड़ा जा सकता है। उपर्युक्त उदाहरण में इस मान को result राशि में पकड़ा गया है। इसके लिए = प्रचालक का प्रयोग किया है। यह अपने दाहिनी ओर के मान को (इस उदाहरण में सशर्त कथन द्वारा लौटाए गए मान को) अपने बाईं ओर की राशि में जमा करता है, जो यहां result है।

सशर्त कथन के बाद वाला prinft उक्ति result के मान को दर्शाता है।

सशर्त कथन सी की उन विरल उक्तियों में से एक है जिन्हें त्रिपक्षीय (ternary) प्रचालक कहा जाता है, यानी ये तीन राशियों पर काम करते हैं। =, &&, / आदि अधिकांश अन्य प्रचालकों में केवल दो पक्ष ही होते हैं, बायां पक्ष (lvalue) और दायां पक्ष (rvalue)। लेकिन सशर्त कथन में ? और : अलगाए हुए तीन पक्ष होते हैं।