'करते हैं ... जबकि' बनाम 'जबकि'

Question 1

संभावित डुप्लिकेट:
जबकि बनाम बनाम जबकि
मैं छोरों के बजाय कब-का उपयोग करना चाहिए?

मैं अब थोड़ी देर के लिए प्रोग्रामिंग कर रहा हूं (2 साल का काम + 4.5 साल की डिग्री + 1 साल का प्री-कॉलेज), और मैंने कभी भी परिचय कार्यक्रम में पाठ्यक्रम में मजबूर होने के लिए लूप-शॉर्ट का उपयोग नहीं किया है। मुझे यह महसूस हो रहा है कि मैं गलत प्रोग्रामिंग कर रहा हूं अगर मैं कभी इतने मौलिक रूप से नहीं चलूं।

क्या ऐसा हो सकता है कि मैं अभी सही परिस्थितियों में नहीं चला हूँ?

ऐसे कुछ उदाहरण क्या हैं जहाँ थोड़ी देर के बजाय एक-एक का उपयोग करना आवश्यक होगा?

(मेरी स्कूली शिक्षा लगभग सभी C / C ++ में थी और मेरा काम C # में है, इसलिए यदि कोई अन्य भाषा है जहाँ यह बिल्कुल समझ में आता है क्योंकि do-whiles अलग तरीके से काम करते हैं, तो ये प्रश्न वास्तव में लागू नहीं होते हैं।)

स्पष्ट करने के लिए ... मुझे एक whileऔर एक के बीच का अंतर पता है do-while। जबकि बाहर निकलने की स्थिति की जांच करता है और फिर कार्य करता है। do-whileकार्य करता है और फिर बाहर निकलने की स्थिति की जाँच करता है।

Question 2

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

do
{
   try to access resource...
   put up message box with retry option

} while (user says retry);

Question 3

यदि कंपाइलर ऑप्टिमाइज़ेशन में सक्षम नहीं है तो डू-ए-बेहतर है। do-जबकि केवल एक ही सशर्त कूद है, जिसके लिए विरोध किया गया है और जबकि एक सशर्त कूद और बिना शर्त कूद है। सीपीयू के लिए, जो पाइपलाइज्ड हैं और शाखा भविष्यवाणी नहीं करते हैं, यह एक तंग लूप के प्रदर्शन में बड़ा बदलाव ला सकता है।

इसके अलावा, चूंकि अधिकांश कंपाइलर इस अनुकूलन को करने के लिए पर्याप्त स्मार्ट हैं, इसलिए विघटित कोड में पाए जाने वाले सभी लूप आमतौर पर करते हैं (यदि डीकॉम्पेइलर यहां तक कि बैकवर्ड लोकल गोटो से लूप को फिर से बनाने के लिए परेशान करता है)।

Question 4

मैंने एक TryDeleteDirectory फ़ंक्शन में इसका उपयोग किया है। यह कुछ इस तरह था

do
{
    try
    {
        DisableReadOnly(directory);
        directory.Delete(true);
    }
    catch (Exception)
    {
        retryDeleteDirectoryCount++;
    }
} while (Directory.Exists(fullPath) && retryDeleteDirectoryCount < 4);

Question 5

जब आप किसी चीज को कम से कम एक बार निष्पादित करना चाहते हैं तो उसके लिए उपयोगी है। के रूप में बनाम जबकि का उपयोग करने के लिए एक अच्छा उदाहरण के रूप में, आप निम्नलिखित बनाना चाहते हैं कहते हैं: एक कैलकुलेटर।

आप लूप का उपयोग करके और प्रत्येक गणना के बाद जांच कर सकते हैं कि क्या वह व्यक्ति प्रोग्राम से बाहर निकलना चाहता है। अब आप शायद मान सकते हैं कि एक बार प्रोग्राम को खोलने के बाद व्यक्ति कम से कम एक बार ऐसा करना चाहता है ताकि आप निम्न कार्य कर सकें:

do
{
    //do calculator logic here
    //prompt user for continue here
} while(cont==true);//cont is short for continue

Question 6

यह एक अप्रत्यक्ष उत्तर की तरह है, लेकिन इस सवाल ने मुझे इसके पीछे के तर्क के बारे में सोचने पर मजबूर कर दिया, और मुझे लगा कि यह साझा करने के लायक हो सकता है।

जैसा कि बाकी सभी ने कहा है, आप एक do ... whileलूप का उपयोग करते हैं जब आप कम से कम एक बार शरीर को निष्पादित करना चाहते हैं। लेकिन आप किन परिस्थितियों में ऐसा करना चाहेंगे?

खैर, स्थितियों का सबसे स्पष्ट वर्ग मैं सोच सकता हूं कि चेक हालत का प्रारंभिक ("अप्रयुक्त") मूल्य वैसा ही होगा जब आप बाहर निकलना चाहते हैं । इसका मतलब यह है कि आपको लूप बॉडी को एक बार गैर-एक्साइटिंग वैल्यू पर प्राइम को प्राइम करने के लिए निष्पादित करने की आवश्यकता है, और फिर उस स्थिति के आधार पर वास्तविक पुनरावृत्ति करें। क्या प्रोग्रामर इतने आलसी होने के साथ, किसी ने इसे एक नियंत्रण संरचना में लपेटने का फैसला किया।

इसलिए, उदाहरण के लिए, एक टाइमआउट के साथ धारावाहिक पोर्ट से पात्रों को पढ़कर रूप ले सकते हैं (पायथन में):

response_buffer = []
char_read = port.read(1)

while char_read:
    response_buffer.append(char_read)
    char_read = port.read(1)

# When there's nothing to read after 1s, there is no more data

response = ''.join(response_buffer)

कोड के दोहराव पर ध्यान दें char_read = port.read(1) :। यदि पायथन में एक do ... whileलूप था, तो मैं इस्तेमाल कर सकता था:

do:
    char_read = port.read(1)
    response_buffer.append(char_read)
while char_read

उन भाषाओं के लिए अतिरिक्त लाभ जो लूप के लिए एक नया स्कोप बनाते हैं: char_readफ़ंक्शन नेमस्पेस को प्रदूषित नहीं करता है। लेकिन यह भी ध्यान दें कि ऐसा करने का एक बेहतर तरीका है, और यह पायथन के Noneमूल्य का उपयोग करके है :

response_buffer = []
char_read = None

while char_read != '':
    char_read = port.read(1)
    response_buffer.append(char_read)

response = ''.join(response_buffer)

तो यहाँ मेरी बात की जड़ है: नल प्रकार के साथ भाषाओं में, स्थिति initial_value == exit_valueअब तक कम अक्सर उठता है, और है कि तुम क्यों यह मुठभेड़ नहीं है हो सकता है। मैं यह नहीं कह रहा हूं कि ऐसा कभी नहीं होता है, क्योंकि अभी भी कई बार ऐसा होता है जब कोई फ़ंक्शन Noneवैध स्थिति का संकेत देने के लिए वापस आ जाएगा । लेकिन मेरी हड़बड़ी और संक्षेप में मानी जाने वाली राय में, यह बहुत अधिक होगा यदि आपने जिन भाषाओं का उपयोग किया है, वे उस मूल्य के लिए अनुमति नहीं देते हैं जो यह दर्शाता है: यह चर अभी तक आरंभ नहीं किया गया है।

यह बिल्कुल सही तर्क नहीं है: वास्तव में, अब जब अशक्त-मूल्य आम हैं, वे बस वैध मूल्यों के सेट का एक और तत्व बनाते हैं जो एक चर ले सकता है। लेकिन व्यावहारिक रूप से, प्रोग्रामर के पास एक चर को समझदार राज्य में अंतर करने का एक तरीका है, जिसमें लूप से बाहर निकलने की स्थिति शामिल हो सकती है, और यह एक असंक्रमित राज्य में हो सकता है।

Question 7

जब मैं स्कूल में था, तब मैंने उनका इस्तेमाल किया।

सिद्धांत रूप में वे उपयोगी होते हैं जब आप चाहते हैं कि लूप बॉडी एक बार बाहर निकलने की स्थिति की जांच से पहले निष्पादित करें। समस्या यह है कि कुछ उदाहरणों के लिए जहां मुझे पहले चेक नहीं चाहिए, आम तौर पर मैं बहुत अंत के बजाय लूप बॉडी के बीच में निकास जांच चाहता हूं । उस मामले में, मैं शरीर में कहीं के for (;;)साथ अच्छी तरह से ज्ञात का उपयोग करना पसंद करता हूं if (condition) exit;।

वास्तव में, यदि मैं पाश निकास स्थिति पर थोड़ा सा अस्थिर हूं, तो कभी-कभी मुझे यह आवश्यक लगता है कि for (;;) {}जहां जरूरत हो, वहां से बाहर निकलने के बयान के साथ लूप लिखना शुरू कर दूं और फिर जब मैं पूरा हो जाऊं तो मैं देख सकता हूं कि क्या यह हो सकता है " " forकोष्ठक के अंदर initilifications, बाहर निकलने की स्थिति, और / या वेतन वृद्धि कोड को साफ करके" ।

Question 8

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

rc = get_something();
while (rc == wrong_stuff)
{
    rc = get_something();
}

do
{
    rc = get_something();
}
while (rc == wrong_stuff);

Question 9

do whileयदि आप कम से कम एक बार कोड ब्लॉक चलाना चाहते हैं। whileदूसरी ओर हमेशा निर्दिष्ट मानदंडों के आधार पर नहीं चलेगा।

Question 10

यह इतना सरल है:

पूर्व शर्त बनाम पोस्टकंडिशन

जबकि (cond) {...} - पूर्व शर्त, यह चेक करने के बाद ही कोड निष्पादित करता है।
do {...} जबकि (cond) - पोस्टकंडिशन, कोड को कम से कम एक बार निष्पादित किया जाता है।

अब जब कि आप रहस्य जानते हैं .. तो उन्हें बुद्धिमानी से उपयोग करें :)

Question 11

मैं देखता हूं कि इस प्रश्न का पर्याप्त उत्तर दिया गया है, लेकिन यह बहुत विशिष्ट उपयोग के मामले को जोड़ना चाहता है। आप का उपयोग करना शुरू कर सकते हैं ... जबकि अधिक बार।

do
{
   ...
} while (0)

बहु-पंक्ति #defines के लिए अक्सर उपयोग किया जाता है। उदाहरण के लिए:

#define compute_values     \
   area = pi * r * r;      \
   volume = area * h

यह इसके लिए ठीक काम करता है:

r = 4;
h = 3;
compute_values;

-लेकिन इसके लिए एक गोत्र है:

if (shape == circle)  compute_values;

जैसा कि यह विस्तार करता है:

if (shape == circle) area = pi *r * r;
volume = area * h;

यदि आप इसे एक में लपेटते हैं ... जबकि (0) लूप इसे ठीक से एक ब्लॉक में फैलता है:

if (shape == circle)
  do
  {
    area = pi * r * r;
    volume = area * h;
  } while (0);

Question 12

अब तक के जवाबों का उपयोग करते समय सामान्य उपयोग को संक्षेप में प्रस्तुत किया जाता है। लेकिन ओपी ने एक उदाहरण के लिए कहा, तो यहां एक है: उपयोगकर्ता इनपुट प्राप्त करें। लेकिन उपयोगकर्ता का इनपुट अमान्य हो सकता है - इसलिए आप इनपुट के लिए पूछें, इसे मान्य करें, यदि यह मान्य है, तो आगे बढ़ें, अन्यथा दोहराएं।

डू-टाइम के साथ, आपको इनपुट मिलता है जबकि इनपुट मान्य नहीं है। एक नियमित रूप से लूप के साथ, आपको एक बार इनपुट मिलता है, लेकिन यदि यह अमान्य है, तो आप इसे तब तक बार-बार प्राप्त करते हैं जब तक कि यह वैध न हो। यह देखना मुश्किल नहीं है कि पूर्व कम है, और अधिक सुंदर है, और सरल बनाए रखने के लिए अगर लूप का शरीर अधिक जटिल हो जाता है।

Question 13

मैंने इसे एक पाठक के लिए उपयोग किया है जो एक ही संरचना को कई बार पढ़ता है।

using(IDataReader reader = connection.ExecuteReader())
{
    do
    {
        while(reader.Read())
        {
            //Read record
        }
    } while(reader.NextResult());
}

Question 14

मैं इस्तेमाल किया एक है do whileजब मैं एक फ़ाइल की शुरुआत में एक प्रहरी मूल्य है कि अन्य की तुलना में पढ़ रहा हूँ, लेकिन, मैं यह असामान्य नहीं लगता है कि इस संरचना नहीं है भी आमतौर पर used-- करते do-whileरों वास्तव में स्थितिजन्य हैं।

-- file --
5
Joe
Bob
Jake
Sarah
Sue

-- code --
int MAX;
int count = 0;
do {
MAX = a.readLine();
k[count] = a.readLine();
count++;
} while(count <= MAX)

Question 15

यहाँ मेरा सिद्धांत है कि अधिकांश लोग (मेरे सहित) क्यों पसंद करते हैं () {} लूप्स टू डू {{जबकि (): ए थोड़ी देर () {} लूप को आसानी से do (सार्थक) (लूप) की तरह प्रदर्शन करने के लिए अनुकूलित किया जा सकता है जबकि विपरीत यह सच नहीं है। एक लूप एक निश्चित तरीके से "अधिक सामान्य" है। इसके अलावा प्रोग्रामर पैटर्न को समझना आसान है। एक लूप सही शुरुआत में कहता है कि इसका अपरिवर्तनीय क्या है और यह एक अच्छी बात है।

यहाँ मैं "अधिक सामान्य" चीज के बारे में क्या कह रहा हूं। यह लो..इस लूप:

do {
 A;
 if (condition) INV=false; 
 B;
} while(INV);

थोड़ी देर के लूप में इसे बदलना सीधा है:

INV=true;
while(INV) {
 A;
 if (condition) INV=false; 
 B;
}

अब, हम एक मॉडल लेते हैं जबकि लूप:

while(INV) {
     A;
     if (condition) INV=false; 
     B;
}

और इसको एक बदलाव के रूप में परिणत करें।इस प्रकार, इस एकरसता को प्राप्त करता है:

if (INV) {
 do
 {
         A;
         if (condition) INV=false; 
         B;

 } while(INV)
}

अब हमारे पास विपरीत छोरों पर दो चेक हैं और यदि अपरिवर्तनीय परिवर्तन आपको इसे दो स्थानों पर अपडेट करना है। एक निश्चित तरीके से करते हैं..उपकरण बॉक्स में विशेष स्क्रूड्राइवर्स की तरह होता है, जिसका आप कभी उपयोग नहीं करते हैं, क्योंकि मानक पेचकश वह सब कुछ करता है जिसकी आपको आवश्यकता होती है।

Question 16

मैं लगभग 12 साल से प्रोग्रामिंग कर रहा हूं और केवल 3 महीने पहले मैं एक ऐसी स्थिति से मिला हूं, जहां ऐसा करना वास्तव में सुविधाजनक था, जबकि एक स्थिति की जांच करने से पहले एक पुनरावृत्ति हमेशा आवश्यक थी। तो लगता है कि आपका बड़ा समय आगे है :)।

Question 17

मैं कल्पना नहीं कर सकता कि कैसे आप एक do...whileलूप का उपयोग किए बिना इस लंबे समय तक चले गए हैं ।

अभी एक और मॉनिटर पर एक है और उस प्रोग्राम में कई ऐसे लूप हैं। वे सभी फॉर्म के हैं:

do
{
    GetProspectiveResult();
}
while (!ProspectIsGood());

Question 18

यह एक सर्वर / उपभोक्ता में काफी सामान्य संरचना है:

DOWHILE (no shutdown requested)
   determine timeout
   wait for work(timeout)
   IF (there is work)
      REPEAT
          process
      UNTIL(wait for work(0 timeout) indicates no work)
      do what is supposed to be done at end of busy period.
   ENDIF
ENDDO

REPEAT UNTIL(cond)एक जा रहा हैdo {...} while(!cond)

कभी-कभी काम के लिए प्रतीक्षा (0) सस्ता CPU वार हो सकता है (यहां तक कि टाइमआउट गणना को समाप्त करना बहुत उच्च आगमन दर के साथ सुधार हो सकता है)। इसके अलावा, कई कतारबद्ध सिद्धांत परिणाम हैं जो व्यस्त अवधि में एक महत्वपूर्ण आंकड़ा के रूप में सेवा प्रदान करते हैं। (उदाहरण के लिए देखें क्लेनकोर - वॉल्यूम 1.)

इसी तरह:

DOWHILE (no shutdown requested)
   determine timeout
   wait for work(timeout)
   IF (there is work)
      set throttle
      REPEAT
          process
      UNTIL(--throttle<0 **OR** wait for work(0 timeout) indicates no work)
   ENDIF
   check for and do other (perhaps polled) work.
ENDDO

जहां check for and do other workमुख्य लूप में रखना महंगा हो सकता है या शायद एक कर्नेल जो एक कुशल waitany(waitcontrol*,n)प्रकार के ऑपरेशन का समर्थन नहीं करता है या शायद एक ऐसी स्थिति है जहां एक प्राथमिकता वाली कतार अन्य कार्य को भुना सकती है और थ्रोटल का उपयोग भुखमरी नियंत्रण के रूप में किया जाता है।

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

मैं वास्तव में छद्म कोड के बारे में बहस में नहीं आना चाहता हूं (उदाहरण के लिए, चाहे शटडाउन को UNTIL में परीक्षण किया जाना चाहिए) या केयरटेकर थ्रेड्स बनाम थ्रेड पूल - इसका मतलब केवल एक विशेष उपयोग के मामले का स्वाद देना है नियंत्रण प्रवाह संरचना।

Question 19

यह मेरी निजी राय है, लेकिन यह सवाल अनुभव में निहित उत्तर के लिए भीख माँगता है:

मैं 38 वर्षों से सी में प्रोग्रामिंग कर रहा हूं, और मैं नियमित कोड में कभी भी do/ whileछोरों का उपयोग नहीं करता हूं ।
इस निर्माण के लिए एकमात्र सम्मोहक उपयोग मैक्रोज़ में है जहाँ यह एक से कई कथनों को एक कथन में लपेट सकता है do { multiple statements } while (0)
मैंने फर्जी त्रुटि का पता लगाने या निरर्थक फ़ंक्शन कॉल के साथ do/ whileछोरों के अनगिनत उदाहरण देखे हैं।
इस अवलोकन के लिए मेरी व्याख्या प्रोग्रामर गलत तरीके से मॉडल समस्याओं के लिए करते हैं जब वे do/ whileछोरों के संदर्भ में सोचते हैं । वे या तो एक महत्वपूर्ण समाप्ति की स्थिति को याद करते हैं या वे प्रारंभिक स्थिति की संभावित विफलता को याद करते हैं जो वे अंत तक चले जाते हैं।

इन कारणों से, मुझे विश्वास है कि जहाँ do/ whileलूप है, वहाँ एक बग है , और मैं नियमित रूप से नौसिखिया प्रोग्रामर को चुनौती देता हूं कि मुझे एक do/ whileलूप दिखाया जाए जहां मैं एक बग को पास नहीं कर सकता।

इस तरह के लूप से आसानी से बचा जा सकता है: एक का उपयोग करें for (;;) { ... }और जहां आवश्यक हो, आवश्यक समाप्ति परीक्षण जोड़ें। यह काफी सामान्य है कि इस तरह के एक से अधिक परीक्षण की आवश्यकता है।

यहाँ एक क्लासिक उदाहरण है:

/* skip the line */
do {
    c = getc(fp);
} while (c != '\n');

यह विफल हो जाएगा यदि फ़ाइल एक नई पंक्ति के साथ समाप्त नहीं होती है। ऐसी फ़ाइल का एक तुच्छ उदाहरण खाली फ़ाइल है।

एक बेहतर संस्करण यह है:

int c;  // another classic bug is to define c as char.
while ((c = getc(fp)) != EOF && c != '\n')
    continue;

वैकल्पिक रूप से, यह संस्करण भी cचर को छुपाता है :

for (;;) {
    int c = getc(fp);
    if (c == EOF || c == '\n')
        break;
}

while (c != '\n');किसी भी खोज इंजन में खोजने का प्रयास करें , और आपको इस तरह के कीड़े मिलेंगे (24 जून, 2017 को पुनः प्राप्त):

Ftp में http://ftp.dante.de/tex-archive/biblio/tib/src/streams.c , फंक्शन getword(stream,p,ignore), में एक do/ whileऔर पर्याप्त रूप से कम से कम 2 बग हैं:

cएक के रूप में परिभाषित किया गया है charऔर
एक संभावित अनंत लूप है while (c!='\n') c=getc(stream);

निष्कर्ष: से बचने के do/ whileलूप और कीड़े के लिए देखो जब आप एक देखते हैं।

Question 20

whileलूप लूप से पहले कंडीशन को चेक करते हैं, do...whileलूप लूप के बाद कंडीशन को चेक करते हैं। यह उपयोगी है कि क्या आप चल रहे पाश से साइड इफेक्ट्स पर स्थिति को आधार बनाना चाहते हैं या, जैसे अन्य पोस्टर ने कहा है, अगर आप चाहते हैं कि लूप कम से कम एक बार चले।

मैं समझता हूं कि आप कहां से आ रहे हैं, लेकिन do-whileकुछ ऐसा है जो शायद ही कभी उपयोग करता है, और मैंने कभी खुद का उपयोग नहीं किया है। आप गलत नहीं कर रहे हैं।

आप गलत नहीं कर रहे हैं। यह कहने की तरह है कि कोई इसे गलत कर रहा है क्योंकि उन्होंने कभी भी byteआदिम का इस्तेमाल नहीं किया है । यह आमतौर पर इस्तेमाल नहीं किया जाता है।

Question 21

सबसे आम परिदृश्य जहां मैं एक do/ whileलूप का उपयोग करता हूं, थोड़ा सा कंसोल प्रोग्राम में होता है जो कुछ इनपुट के आधार पर चलता है और उपयोगकर्ता द्वारा पसंद किए जाने पर कई बार दोहराएगा। जाहिर है यह सांत्वना कार्यक्रम के लिए कोई मतलब नहीं चलाने के लिए कोई मतलब नहीं है; लेकिन पहली बार से परे यह उपयोगकर्ता के लिए है - इसलिए do/ whileसिर्फ के बजाय while।

यह उपयोगकर्ता को वांछित होने पर अलग-अलग इनपुट का एक गुच्छा आज़माने की अनुमति देता है।

do
{
   int input = GetInt("Enter any integer");
   // Do something with input.
}
while (GetBool("Go again?"));

मुझे संदेह है कि सॉफ्टवेयर डेवलपर इन दिनों कम do/ whileज्यादा का उपयोग करते हैं, अब जबकि व्यावहारिक रूप से सूरज के नीचे हर कार्यक्रम में किसी न किसी प्रकार का जीयूआई होता है। यह कंसोल ऐप्स के साथ अधिक समझ में आता है, क्योंकि निर्देशों को प्रदान करने या उपयोगकर्ता को नई जानकारी के साथ संकेत देने के लिए आउटपुट को लगातार ताज़ा करने की आवश्यकता होती है। एक जीयूआई के साथ, इसके विपरीत, उपयोगकर्ता को यह जानकारी प्रदान करने वाला पाठ सिर्फ एक फॉर्म पर बैठ सकता है और कभी भी प्रोग्राम को दोहराए जाने की आवश्यकता नहीं है।

Question 22

मैं फ़ाइलों में पढ़ते समय हर समय लूप का उपयोग करता हूं। मैं बहुत सी पाठ फ़ाइलों के साथ काम करता हूं जिसमें हेडर में टिप्पणियां शामिल हैं:

# some comments
# some more comments
column1 column2
  1.234   5.678
  9.012   3.456
    ...     ...

मैं "कॉलम 1 कॉलम 2" लाइन तक पढ़ने के लिए एक डू-लूप का उपयोग करूंगा ताकि मैं ब्याज के कॉलम को देख सकूं। यहाँ छद्म कोड है:

do {
    line = read_line();
} while ( line[0] == '#');
/* parse line */

तब मैं बाकी फ़ाइल के माध्यम से पढ़ने के लिए थोड़ी देर करूंगा।

Question 23

एक गीज़र प्रोग्रामर होने के नाते, मेरे कई स्कूल प्रोग्रामिंग प्रोजेक्ट्स में टेक्स्ट मेनू संचालित इंटरैक्शन का उपयोग किया गया था। वस्तुतः सभी ने मुख्य प्रक्रिया के लिए निम्नलिखित तर्क जैसे कुछ का उपयोग किया:

do
    display options
    get choice
    perform action appropriate to choice
while choice is something other than exit

स्कूल के दिनों से, मैंने पाया है कि मैं लूप का उपयोग अधिक बार करता हूं।

Question 24

जब मैंने रिजल्ट सेट्स को देखा तो उनमें से एक एप्लीकेशन मैंने ओरेकल में देखा।

एक बार जब आप एक परिणाम सेट कर लेते हैं, तो आप पहले इसे (डू) से प्राप्त करते हैं और उस बिंदु से .. जाँचते हैं कि क्या एक तत्व वापस आता है या नहीं (जबकि तत्व पाया गया है ..) .. वही किसी अन्य के लिए लागू हो सकता है " लाने जैसा "कार्यान्वयन।

Question 25

मैंने इसे एक ऐसे फंक्शन में इस्तेमाल किया है जो utf-8 स्ट्रिंग में अगले चरित्र की स्थिति लौटाता है:

char *next_utf8_character(const char *txt)
{
    if (!txt || *txt == '\0')
        return txt;

    do {
        txt++;
    } while (((signed char) *txt) < 0 && (((unsigned char) *txt) & 0xc0) == 0xc0)

    return (char *)txt;
}

ध्यान दें, यह फ़ंक्शन मन से लिखा गया है और परीक्षण नहीं किया गया है। मुद्दा यह है कि आपको पहले चरण को वैसे भी करना होगा और स्थिति का मूल्यांकन करने से पहले आपको इसे करना होगा।

Question 26

किसी भी प्रकार का कंसोल इनपुट डू-टाइम के साथ अच्छी तरह से काम करता है क्योंकि आप पहली बार प्रॉम्प्ट करते हैं, और जब भी इनपुट सत्यापन विफल हो जाता है, तब पुनः संकेत देते हैं।

Question 27

हालांकि यहाँ बहुत सारे जवाब हैं, मेरा लेना है। यह सब अनुकूलन के लिए नीचे आता है। मैं दो उदाहरण दिखाऊँगा जहाँ एक तेज़ है तो दूसरा।

मामला एक: while

string fileName = string.Empty, fullPath = string.Empty;

while (string.IsNullOrEmpty(fileName) || File.Exists(fullPath))
{
    fileName = Guid.NewGuid().ToString() + fileExtension;
    fullPath = Path.Combine(uploadDirectory, fileName);
}

केस 2: do while

string fileName = string.Empty, fullPath = string.Empty;

do
{
    fileName = Guid.NewGuid().ToString() + fileExtension;
    fullPath = Path.Combine(uploadDirectory, fileName);
}
while (File.Exists(fullPath));

तो वहाँ दो एक ही काम करेंगे। लेकिन एक मौलिक अंतर है और वह यह है कि थोड़ी देर में प्रवेश करने के लिए अतिरिक्त विवरण की आवश्यकता होती है। जो बदसूरत है क्योंकि मान लीजिए कि Guidकक्षा के प्रत्येक संभावित परिदृश्य को पहले से ही एक संस्करण के अलावा लिया गया है। इसका मतलब है कि मुझे 5,316,911,983,139,663,491,615,228,241,121,400,000कई बार लूप करना पड़ेगा । हर बार जब मैं अपने अंतिम समय पर पहुँचता हूँ तो मुझे string.IsNullOrEmpty(fileName)चेक करने की आवश्यकता होगी । तो यह सीपीयू काम का एक छोटा सा अंश, थोड़ा सा ऊपर ले जाएगा। लेकिन क्या यह बहुत छोटा कार्य है जो Guidकक्षा में संभव संयोजनों से होता है और हम घंटों, दिनों, महीनों या अतिरिक्त समय के बारे में बात कर रहे हैं?

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

Question 28

मुझे इन दोनों को समझना पसंद है:
while -> 'जब तक दोहराएं',
do ... while-> 'अगर दोहराएं'।

Question 29

मैं एक स्थिति के लिए उपयोग करने के लिए उचित लूप पर शोध करते हुए इस पार भाग गया। मेरा मानना है कि यह पूरी तरह से एक सामान्य स्थिति को संतुष्ट करेगा जहां एक करते हैं .. जबकि लूप थोड़ी देर के लूप (सी # भाषा) से बेहतर कार्यान्वयन है, क्योंकि आपने कहा था कि काम के लिए आपका प्राथमिक है)।

मैं SQL क्वेरी के परिणामों के आधार पर स्ट्रिंग्स की एक सूची तैयार कर रहा हूं। मेरी क्वेरी द्वारा दी गई ऑब्जेक्ट SQLDataReader है। इस ऑब्जेक्ट में रीड () नामक एक फ़ंक्शन है जो ऑब्जेक्ट को डेटा की अगली पंक्ति के लिए आगे बढ़ाता है, और दूसरी पंक्ति होने पर वापस लौटाता है। यदि दूसरी पंक्ति नहीं है तो यह गलत हो जाएगी।

इस जानकारी का उपयोग करते हुए, मैं प्रत्येक पंक्ति को एक सूची में वापस करना चाहता हूं, फिर रुकें जब वापस लौटने के लिए अधिक डेटा नहीं है। A Do ... जबकि लूप इस स्थिति में सबसे अच्छा काम करता है क्योंकि यह सुनिश्चित करता है कि सूची में एक आइटम जोड़ने से एक और पंक्ति होने पर जाँच होगी। इसका कारण यह होना चाहिए, जबकि (स्थिति) को जाँचने से पहले यह होना चाहिए कि जब यह जाँच करता है, तो यह आगे भी बढ़े। इस स्थिति में थोड़ी देर के लूप का उपयोग करने से यह उस विशेष कार्य की प्रकृति के कारण पहली पंक्ति को बायपास कर देगा।

संक्षेप में:

यह मेरी स्थिति में काम नहीं करेगा।

    //This will skip the first row because Read() returns true after advancing.
    while (_read.NextResult())
           {
               list.Add(_read.GetValue(0).ToString());
           }

   return list;

यह करेगा।

    //This will make sure the currently read row is added before advancing.
    do
        {
            list.Add(_read.GetValue(0).ToString());
        } 
        while (_read.NextResult());

    return list;

Question 30

Console.WriteLine("hoeveel keer moet je de zin schrijven?");
        int aantal = Convert.ToInt32(Console.ReadLine());
        int counter = 0;

        while ( counter <= aantal)
        {
            Console.WriteLine("Ik mag geen stiften gooien");
            counter = counter + 1;