अनंत लूप: Difference between revisions

From Vigyanwiki
No edit summary
No edit summary
 
(19 intermediate revisions by 6 users not shown)
Line 1: Line 1:
{{short description|Programming idiom}}
 
{{About|the programming term|the street named after this term|Infinite Loop (street)|the book by Michael S. Malone|Infinite Loop (book)}}
 
{{Redirect|Endless loop|EP by Eiko Shimamiya|Endless Loop}}
[[कंप्यूटर प्रोग्रामिंग]] में, '''अनंत लूप''' (या इनफिनिट लूप)<ref>{{cite web
{{Loop constructs}}
[[कंप्यूटर प्रोग्रामिंग]] में, एक अनंत लूप (या अंतहीन लूप)<ref>{{cite web
   |url=https://www.yourdictionary.com/endless-loop
   |url=https://www.yourdictionary.com/endless-loop
   |title=Endless loop dictionary definition
   |title=Endless loop dictionary definition
Line 17: Line 15:
   |archive-url=https://web.archive.org/web/20190715101446/https://whatis.techtarget.com/definition/infinite-loop-endless-loop
   |archive-url=https://web.archive.org/web/20190715101446/https://whatis.techtarget.com/definition/infinite-loop-endless-loop
   |url-status=live
   |url-status=live
   }}</ref> निर्देशों का एक क्रम है जो, जैसा कि लिखा गया है, अंतहीन रूप से जारी रहेगा, जब तक कि कोई बाहरी हस्तक्षेप नहीं होता (प्लग खींचो)। यह जानबूझकर हो सकता है।
   }}</ref> निर्देशों का क्रम है, जो लिखित रूप में, अंतहीन रूप से जारी रहेगा, जब तक कि कोई बाहरी हस्तक्षेप नहीं होता (प्लग खींचो) है। यह इच्छानुरूप हो सकता है।


== सिंहावलोकन ==
== अवलोकन ==
यह इससे भिन्न है:
यह इससे भिन्न है:
* एक प्रकार का कंप्यूटर प्रोग्राम जो एक ही निर्देश को लगातार तब तक चलाता है जब तक कि इसे बंद या बाधित नहीं किया जाता है।<ref>{{cite news
* एक प्रकार का कंप्यूटर प्रोग्राम जो निर्देश को लगातार तब तक चलाता है जब तक कि इसे बंद या बाधित नहीं किया जाता है।<ref>{{cite news
   |newspaper=[[The New York Times]]
   |newspaper=[[The New York Times]]
   |url=https://archive.nytimes.com/www.nytimes.com/library/tech/99/08/biztech/articles/16digi.html
   |url=https://archive.nytimes.com/www.nytimes.com/library/tech/99/08/biztech/articles/16digi.html
Line 32: Line 30:
   |url-status=live
   |url-status=live
   }}</ref>
   }}</ref>
निम्नलिखित [[स्यूडोकोड]] पर विचार करें:
निम्नलिखित [[स्यूडोकोड]] पर विचार करें:<syntaxhighlight lang="d">
<वाक्यविन्यास लैंग = लुआ>
how_many = 0
कैसे_कई = 0
while is_there_more_data() do
जबकि is_there_more_data() करते हैं
     how_many = how_many + 1
     कैसे_कई = कैसे_कई + 1
end
अंत
display "the number of items counted = " how_many
गिने गए आइटमों की संख्या प्रदर्शित करें = how_many
</syntaxhighlight>एक ही निर्देश लगातार तब तक चलाए जाते थे जब तक कि फलन द्वारा किसी बिंदु पर लौटाए गए फ़ालसे द्वारा रोका या बाधित. . नहीं किया जाता है कि क्या अधिक डेटा है।
</वाक्यविन्यास हाइलाइट>


जब तक इसे रोका या बाधित नहीं किया गया तब तक वही निर्देश लगातार चलाए गए। . . फ़ंक्शन is_there_more_data द्वारा किसी बिंदु पर लौटाए गए FALSE द्वारा।
इसके विपरीत, निम्न लूप अपने आप समाप्त नहीं होता है:<syntaxhighlight lang="d">
 
birds = 1
इसके विपरीत, निम्न लूप अपने आप समाप्त नहीं होगा:
fish = 2
<वाक्यविन्यास लैंग = लुआ>
while birds + fish > 1 do
पक्षी = 1
     birds = 3 - birds
मछली = 2
     fish = 3 - fish
जबकि पक्षी + मछली > 1 करते हैं
end
     पक्षी = 3 - पक्षी
</syntaxhighlight>बर्ड्स वैकल्पिक रूप से 1 या 2 होंगे, चूंकि फिश वैकल्पिक रूप से 2 या 1 होगी। लूप तब तक नहीं रुकेगा जब तक कि कोई बाहरी हस्तक्षेप नहीं होता (प्लग को खींचें) हैं।
     मछली = 3 - मछली
अंत
</वाक्यविन्यास हाइलाइट>
 
पक्षी वैकल्पिक रूप से 1 या 2 होंगे, जबकि मछली वैकल्पिक रूप से 2 या 1 होगी। लूप तब तक नहीं रुकेगा जब तक कि कोई बाहरी हस्तक्षेप नहीं होता (प्लग को खींचें)।


== विवरण ==
== विवरण ==
एक अनंत लूप एक [[कंप्यूटर प्रोग्राम]] में निर्देशों का एक क्रम है जो अंतहीन रूप से लूप करता है, या तो नियंत्रण प्रवाह के कारण # लूप्स की कोई समाप्ति स्थिति नहीं होती है,<ref>{{cite magazine
इनफिनिट लूप [[कंप्यूटर प्रोग्राम]] में निर्देशों का क्रम है जो या तो लूप के बिना समाप्त होने वाली स्थिति के कारण अंतहीन रूप से लूप करता है,<ref>{{cite magazine
   |magazine=Flow Journal
   |magazine=Flow Journal
   |url=http://www.flowjournal.org/tag/loop-media/?print=print-search
   |url=http://www.flowjournal.org/tag/loop-media/?print=print-search
Line 66: Line 58:
   |archive-url=https://web.archive.org/web/20200801213624/http://www.flowjournal.org/tag/loop-media/?print=print-search
   |archive-url=https://web.archive.org/web/20200801213624/http://www.flowjournal.org/tag/loop-media/?print=print-search
   |url-status=live
   |url-status=live
   }}</ref> एक ऐसा होना जो कभी पूरा नहीं हो सकता, या एक ऐसा जो लूप को फिर से शुरू करने का कारण बनता है। [[सहकारी मल्टीटास्किंग]] वाले पुराने [[ऑपरेटिंग सिस्टम]] में,<ref>also known as non-preemptive-multitasking: {{cite magazine
   }}</ref> जिसमें कभी भी पूरा नहीं किया जा सकता है या जो लूप को फिर से प्रारंभ करने का कारण बनता है। [[सहकारी मल्टीटास्किंग]] के साथ पुराने [[ऑपरेटिंग सिस्टम|ऑपरेटिंग प्रणाली]] में,<ref>also known as non-preemptive-multitasking: {{cite magazine
   |magazine=[[PC Magazine]]
   |magazine=[[PC Magazine]]
   |url=https://www.pcmag.com/encyclopedia/term/48051/non-preemptive-multitasking
   |url=https://www.pcmag.com/encyclopedia/term/48051/non-preemptive-multitasking
Line 74: Line 66:
   |archive-url=https://web.archive.org/web/20190726232111/https://www.pcmag.com/encyclopedia/term/48051/non-preemptive-multitasking
   |archive-url=https://web.archive.org/web/20190726232111/https://www.pcmag.com/encyclopedia/term/48051/non-preemptive-multitasking
   |url-status=live
   |url-status=live
   }}</ref> अनंत लूप सामान्य रूप से पूरे सिस्टम को अनुत्तरदायी बना देते हैं। अब प्रचलित प्रीमेप्टिव मल्टीटास्किंग मॉडल के साथ, अनंत लूप आमतौर पर प्रोग्राम को सभी उपलब्ध प्रोसेसर समय का उपभोग करने का कारण बनते हैं, लेकिन आमतौर पर उपयोगकर्ता द्वारा इसे समाप्त किया जा सकता है। व्यस्त प्रतीक्षा लूप को कभी-कभी अनंत लूप भी कहा जाता है। कंप्यूटर [[हैंग (कंप्यूटिंग)]] के लिए अनंत लूप एक संभावित कारण हैं; अन्य में थ्रैशिंग (कंप्यूटर विज्ञान), [[गतिरोध]] और विभाजन दोष शामिल हैं।
   }}</ref> इनफिनिट लूप सामान्य रूप से पूरे प्रणाली को अनुत्तरदायी बना देते हैं। अब प्रचलित प्रीमेप्टिव मल्टीटास्किंग मॉडल के साथ, इनफिनिट लूप सामान्यतः प्रोग्राम को सभी उपलब्ध प्रोसेसर समय का उपभोग करने का कारण बनते हैं, किन्तु सामान्यतः उपयोगकर्ता द्वारा इसे समाप्त किया जा सकता है। व्यस्त प्रतीक्षा लूप को कभी-कभी इनफिनिट लूप भी कहा जाता है। कंप्यूटर [[हैंग (कंप्यूटिंग)|फ्रीजिंग (कंप्यूटिंग)]] के लिए इनफिनिट लूप संभावित कारण हैं; अन्य में थ्रैशिंग (कंप्यूटर विज्ञान), [[गतिरोध|डेडलॉक]] और एक्सेस उल्लंघन सम्मिलित हैं।


== इरादा बनाम अनपेक्षित लूपिंग ==
== उद्देश्य बनाम अनपेक्षित लूपिंग ==
लूपिंग निर्देशों का एक सेट दोहरा रहा है जब तक कि एक विशिष्ट शर्त पूरी नहीं हो जाती। एक अनंत लूप तब होता है जब लूप की कुछ अंतर्निहित विशेषता के कारण स्थिति कभी पूरी नहीं होगी।
लूपिंग निर्देशों का सेट दोहरा रहा है जब तक कि विशिष्ट शर्त पूरी नहीं हो जाती है। इनफिनिट लूप तब होता है जब लूप की कुछ अंतर्निहित विशेषता के कारण स्थिति कभी पूरी नहीं होती है।


=== जानबूझकर लूपिंग ===
=== निश्चयपूर्वक लूपिंग ===
ऐसी कुछ स्थितियाँ होती हैं जब यह वांछित व्यवहार होता है। उदाहरण के लिए, कार्ट्रिज-आधारित गेम कंसोल पर आमतौर पर उनके मुख्य लूप में कोई निकास स्थिति नहीं होती है, क्योंकि प्रोग्राम से बाहर निकलने के लिए कोई ऑपरेटिंग सिस्टम नहीं होता है; लूप तब तक चलता है जब तक कंसोल बंद नहीं हो जाता।
ऐसी कुछ स्थितियाँ होती हैं जब यह वांछित व्यवहार होता है। उदाहरण के लिए, कार्ट्रिज-आधारित गेम कंसोल पर सामान्यतः उनके मुख्य लूप में कोई निकास स्थिति नहीं होती है, क्योंकि कंसोल के बंद होने तक प्रोग्राम के लूप से बाहर निकलने के लिए कोई ऑपरेटिंग प्रणाली नहीं होता है।


आधुनिक इंटरएक्टिव कंप्यूटरों के लिए आवश्यक है कि कंप्यूटर लगातार उपयोगकर्ता इनपुट या डिवाइस गतिविधि की निगरानी करे, इसलिए कुछ मौलिक स्तर पर एक अनंत प्रोसेसिंग [[निष्क्रिय पाश]] होता है जो डिवाइस के बंद या रीसेट होने तक जारी रहना चाहिए। [[अपोलो गाइडेंस कंप्यूटर]] में, उदाहरण के लिए, यह बाहरी लूप Exec प्रोग्राम में समाहित था,<ref>{{cite web
आधुनिक इंटरएक्टिव कंप्यूटरों के लिए आवश्यक है कि कंप्यूटर उपयोगकर्ता इनपुट या डिवाइस गतिविधि के लिए लगातार निगरानी रखे जिससे कुछ मौलिक स्तर पर इनफिनिट प्रोसेसिंग [[निष्क्रिय पाश|आइडल लूप]] होता है जो डिवाइस के बंद या रीसेट होने तक जारी रहना चाहिए। उदाहरण के लिए, [[अपोलो गाइडेंस कंप्यूटर]] में यह बाहरी लूप Exec प्रोग्राम में समाहित था,<ref>{{cite web
   |url=http://klabs.org/history/history_docs/mit_docs/1711.pdf
   |url=http://klabs.org/history/history_docs/mit_docs/1711.pdf
   |title=The History of Apollo On-board Guidance, Navigation, and Control
   |title=The History of Apollo On-board Guidance, Navigation, and Control
Line 92: Line 84:
   |archive-url=https://web.archive.org/web/20161105060425/http://klabs.org/history/history_docs/mit_docs/1711.pdf
   |archive-url=https://web.archive.org/web/20161105060425/http://klabs.org/history/history_docs/mit_docs/1711.pdf
   |url-status=live
   |url-status=live
   }}</ref> और अगर कंप्यूटर के पास करने के लिए बिल्कुल कोई दूसरा काम नहीं था तो यह लूप एक डमी जॉब चलाएगा जो कंप्यूटर गतिविधि सूचक प्रकाश को बंद कर देगा।
   }}</ref> और यदि कंप्यूटर के पास करने के लिए बिल्कुल कोई दूसरा काम नहीं था तो यह लूप डमी जॉब चलाएगा जो कंप्यूटर गतिविधि सूचक प्रकाश को बंद कर देगा।


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


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


=== अनजाने में लूपिंग ===
=== अपरिचित में लूपिंग ===
बहुधा, इस शब्द का प्रयोग उन स्थितियों के लिए किया जाता है जब यह अभीष्ट परिणाम नहीं होता है; यानी जब यह एक [[सॉफ्टवेयर बग]] है।<ref>{{cite web
प्रायः, इस शब्द का प्रयोग उन स्थितियों के लिए किया जाता है जब यह अभीष्ट परिणाम नहीं होता है; अर्थात् जब यह [[सॉफ्टवेयर बग]] है।<ref>{{cite web
   |url=https://nyxcrossword.com/2013/10/1013-13-new-york-times-crossword.html
   |url=https://nyxcrossword.com/2013/10/1013-13-new-york-times-crossword.html
   |title=New York Times Crossword Answers
   |title=New York Times Crossword Answers
Line 109: Line 101:
   |archive-url=https://web.archive.org/web/20200802040416/https://nyxcrossword.com/2013/10/1013-13-new-york-times-crossword.html
   |archive-url=https://web.archive.org/web/20200802040416/https://nyxcrossword.com/2013/10/1013-13-new-york-times-crossword.html
   |url-status=live
   |url-status=live
   }}</ref> नौसिखिए प्रोग्रामरों में ऐसी त्रुटियां सबसे आम हैं, लेकिन अनुभवी प्रोग्रामर द्वारा भी की जा सकती हैं, क्योंकि उनके कारण काफी सूक्ष्म हो सकते हैं।
   }}</ref> नोविस प्रोग्रामरों में ऐसी त्रुटियां सबसे सामान्य हैं, किन्तु अनुभवी प्रोग्रामर द्वारा भी की जा सकती हैं, क्योंकि उनके कारण अधिक सूक्ष्म हो सकते हैं।


एक सामान्य कारण, उदाहरण के लिए, यह है कि प्रोग्रामर एक [[लिंक्ड सूची]] या ट्री ([[डेटा संरचना]]) जैसे डेटा संरचना में नोड्स के अनुक्रम पर पुनरावृति करना चाहता है, प्रत्येक नोड के लिए एक बार लूप कोड निष्पादित करता है। अनुचित रूप से गठित लिंक डेटा संरचना में एक संदर्भ लूप बना सकते हैं, जहां एक नोड दूसरे से लिंक होता है जो पहले अनुक्रम में होता है। यह डेटा संरचना का हिस्सा एक रिंग (डेटा संरचना) में बनाता है, जिससे भोली कोड हमेशा के लिए लूप हो जाता है।
सामान्य कारण, उदाहरण के लिए, यह है कि प्रोग्रामर [[लिंक्ड सूची]] या ट्री ([[डेटा संरचना]]) जैसे डेटा संरचना में नोड्स के अनुक्रम पर पुनरावृति करना चाहता है, प्रत्येक नोड के लिए बार लूप कोड निष्पादित करता है। अनुचित रूप से गठित लिंक डेटा संरचना में संदर्भ लूप बना सकते हैं, जहां नोड दूसरे से लिंक होता है जो पहले अनुक्रम में होता है। यह डेटा संरचना का हिस्सा रिंग (डेटा संरचना) में बनाता है, जिससे सरल कोड हमेशा के लिए लूप हो जाता है।


जबकि कोड के गहन निरीक्षण से अधिकांश अनंत लूप पाए जा सकते हैं, यह निर्धारित करने के लिए कोई सामान्य तरीका नहीं है कि क्या दिया गया प्रोग्राम कभी रुकेगा या हमेशा के लिए चलेगा; यह [[रुकने की समस्या]] की अपरिहार्य समस्या है।<ref>{{cite web|url=https://www.geeksforgeeks.org/halting-problem-in-theory-of-computation|title=Halting Problem in Theory of Computation|date=3 October 2018|access-date=22 January 2020|archive-date=9 August 2020|archive-url=https://web.archive.org/web/20200809100104/https://www.geeksforgeeks.org/halting-problem-in-theory-of-computation/|url-status=live}}</ref>
चूंकि कोड के गहन निरीक्षण से अधिकांश इनफिनिट लूप पाए जा सकते हैं, यह निर्धारित करने के लिए कोई सामान्य विधि नहीं है कि क्या दिया गया प्रोग्राम कभी रुकेगा या हमेशा के लिए चलेगा; यह [[रुकने की समस्या|हॉल्टिंग]] समस्या की अनिश्चितता है।<ref>{{cite web|url=https://www.geeksforgeeks.org/halting-problem-in-theory-of-computation|title=Halting Problem in Theory of Computation|date=3 October 2018|access-date=22 January 2020|archive-date=9 August 2020|archive-url=https://web.archive.org/web/20200809100104/https://www.geeksforgeeks.org/halting-problem-in-theory-of-computation/|url-status=live}}</ref>




== रुकावट ==
== व्यवधान ==
जब तक सिस्टम उत्तरदायी है, अनंत लूप को अक्सर प्रक्रिया को सिग्नल भेजकर बाधित किया जा सकता है (जैसे कि यूनिक्स में [[सिगिनट (पॉज़िक्स)]]), या प्रोसेसर के लिए बाधा, जिससे वर्तमान प्रक्रिया को निरस्त किया जा सकता है। यह एक [[कार्य प्रबंधक]] में किया जा सकता है, टर्मिनल में [[नियंत्रण-सी]] कमांड के साथ,<ref>{{cite web
जब तक प्रणाली उत्तरदायी है, इनफिनिट लूप को प्रायः प्रक्रिया को सिग्नल भेजकर बाधित किया जा सकता है (जैसे कि यूनिक्स में [[सिगिनट (पॉज़िक्स)]]), या प्रोसेसर के लिए बाधा, जिससे वर्तमान प्रक्रिया को निरस्त किया जा सकता है। इसे टर्मिनल के [[नियंत्रण-सी]] कमांड के साथ<ref>{{cite web
   |url=https://pen-testing.sans.org/resources/papers/gcih/buffer-overflow-exploit-dameware-remote-control-software-104168
   |url=https://pen-testing.sans.org/resources/papers/gcih/buffer-overflow-exploit-dameware-remote-control-software-104168
   |title=A Buffer Overflow Exploit Against the DameWare Remote Control software
   |title=A Buffer Overflow Exploit Against the DameWare Remote Control software
Line 126: Line 118:
   |archive-url=https://web.archive.org/web/20200724200739/https://pen-testing.sans.org/resources/papers/gcih/buffer-overflow-exploit-dameware-remote-control-software-104168
   |archive-url=https://web.archive.org/web/20200724200739/https://pen-testing.sans.org/resources/papers/gcih/buffer-overflow-exploit-dameware-remote-control-software-104168
   |url-status=live
   |url-status=live
   }}</ref> या [[मारना (आदेश)]] कमांड या [[सिस्टम कॉल]] का उपयोग करके। हालांकि, यह हमेशा काम नहीं करता है, क्योंकि हो सकता है कि प्रक्रिया संकेतों का जवाब नहीं दे रही हो या प्रोसेसर अबाधित स्थिति में हो सकता है, जैसे कि [[सिरिक्स कोमा बग]] (एक [[निर्देश पाइपलाइन]] में अबाधित निर्देशों को ओवरलैप करने के कारण)। कुछ मामलों में [[SIGKILL]] जैसे अन्य सिग्नल काम कर सकते हैं, क्योंकि उन्हें प्रतिक्रियात्मक होने के लिए प्रक्रिया की आवश्यकता नहीं होती है, जबकि अन्य मामलों में लूप को सिस्टम शटडाउन से कम नहीं किया जा सकता है।
   }}</ref> के साथ या [[मारना (आदेश)|किल (आदेश)]] कमांड या [[सिस्टम कॉल|प्रणाली कॉल]] का उपयोग करके [[कार्य प्रबंधक]] में किया जा सकता है। चूंकि, यह हमेशा काम नहीं करता है, क्योंकि हो सकता है कि प्रक्रिया संकेतों का उत्तर नहीं दे रही हो या प्रोसेसर अबाधित स्थिति में हो सकता है, जैसे कि [[सिरिक्स कोमा बग]] ( [[निर्देश पाइपलाइन]] में अबाधित निर्देशों को ओवरलैप करने के कारण)। कुछ स्थितियों में [[SIGKILL|सिगकिल]] जैसे अन्य सिग्नल काम कर सकते हैं, क्योंकि उन्हें प्रतिक्रियात्मक होने के लिए प्रक्रिया की आवश्यकता नहीं होती है, चूंकि अन्य स्थितियों में लूप को प्रणाली शटडाउन से कम नहीं किया जा सकता है।
 
== भाषा समर्थन ==
{{see also|Control flow}}
विभिन्न नियंत्रण प्रवाह निर्माणों का उपयोग करके अनंत लूपों को लागू किया जा सकता है। आमतौर पर, असंरचित प्रोग्रामिंग में यह जम्प बैक अप ([[के लिए जाओ]]) होता है, जबकि संरचित प्रोग्रामिंग में यह एक अनिश्चित लूप (जबकि लूप) होता है जो कभी भी समाप्त नहीं होता है, या तो स्थिति को छोड़ कर या स्पष्ट रूप से इसे सही पर सेट करके, जैसा कि <code>while (true) ...</code>.


कुछ भाषाओं में अनंत लूप के लिए विशेष निर्माण होते हैं, आमतौर पर अनिश्चित लूप से स्थिति को छोड़ कर। उदाहरणों में शामिल हैं एडा (<code>loop ... end loop</code>),<ref>[[b:Ada Programming/Control#Endless Loop|Ada Programming: Control: Endless Loop]]</ref> फोरट्रान (<code>DO ... END DO</code>), जाना (<code>for { ... }</code>), माणिक (<code>loop do ... end</code>), और जंग (<code>loop { ... }</code>).
== लैंग्वेज समर्थन ==
{{see also|बहाव को नियंत्रित करें}}
विभिन्न नियंत्रण प्रवाह निर्माणों का उपयोग करके इनफिनिट लूपों को प्रायुक्त किया जा सकता है। सामान्यतः, असंरचित प्रोग्रामिंग में यह जम्प बैक अप ([[के लिए जाओ]]) होता है, चूंकि संरचित प्रोग्रामिंग में यह अनिश्चित लूप (चूंकि लूप) होता है जो या तो स्थिति को छोड़ कर या स्पष्ट रूप से इसे <code>while (true) ...</code> के रूप में सेट करके कभी समाप्त नहीं होता है।


== जानबूझकर अनंत छोरों के उदाहरण ==
कुछ लैंग्वेजेस में इनफिनिट लूप के लिए विशेष रूप से अनिश्चित लूप से शर्त को हटाकर विशेष निर्माण होते हैं। उदाहरणों में एडा (<code>loop ... end loop</code>),<ref>[[b:Ada Programming/Control#Endless Loop|Ada Programming: Control: Endless Loop]]</ref> फोरट्रान (<code>DO ... END DO</code>), गो (<code>for { ... }</code>), रूबी (<code>loop do ... end</code>), और रस्ट (<code>loop { ... }</code>) सम्मिलित हैं।
एक साधारण उदाहरण ([[सी (प्रोग्रामिंग भाषा)]] में):


<वाक्यविन्यास लैंग = सी लाइन = 1>
== निश्चयपूर्वक इनफिनिट किनारों के उदाहरण ==
#शामिल <stdio.h>
साधारण उदाहरण ([[सी (प्रोग्रामिंग भाषा)|सी (प्रोग्रामिंग लैंग्वेज)]] में):<syntaxhighlight line="1" start="1">
#include <stdio.h>


मुख्य प्रवेश बिंदु()
int main()
{
{
   के लिए (;;) // या समकक्ष, जबकि (1)
   for (;;) // or equivalently, while (1)
     ;
     ;
   वापसी 0;
   return 0;
}
}
</वाक्यविन्यास हाइलाइट>
</syntaxhighlight>
फार्म <code>for (;;)</code> अनंत लूप के लिए पारंपरिक है, [[सी प्रोग्रामिंग लैंग्वेज]] के मानक संदर्भ में दिखाई देता है, और अक्सर इसका स्पष्ट रूप से हमेशा के लिए उच्चारण किया जाता है।<ref>{{Cite web |url=https://stackoverflow.com/questions/20186809/endless-loop-in-c-c |title=Endless loop in C/C++ |url-status=live |archive-url=https://web.archive.org/web/20160803202212/http://stackoverflow.com/questions/20186809/endless-loop-in-c-c |archive-date=2016-08-03}}</ref>
यह एक लूप है जो अनंत लूप को बिना रुके प्रिंट करेगा।


1980 के दशक की [[बुनियादी प्रोग्रामिंग भाषा]] में एक समान उदाहरण:
इनफिनिट <code>for (;;)</code> का रूप पारंपरिक है, जो [[सी प्रोग्रामिंग लैंग्वेज]] के मानक संदर्भ में दिखाई देता है, और प्रायः इसका स्पष्ट रूप से हमेशा के लिए उच्चारण किया जाता है।<ref>{{Cite web |url=https://stackoverflow.com/questions/20186809/endless-loop-in-c-c |title=Endless loop in C/C++ |url-status=live |archive-url=https://web.archive.org/web/20160803202212/http://stackoverflow.com/questions/20186809/endless-loop-in-c-c |archive-date=2016-08-03}}</ref>
<वाक्यविन्यास लैंग = जीडब्ल्यूबेसिक>
10 अनंत लूप प्रिंट करें
20 गोटो 10
</वाक्यविन्यास हाइलाइट>


डॉस बैच फ़ाइलों में एक समान उदाहरण:
यह लूप है जो इनफिनिट लूप को बिना रुके प्रिंट करेगा।
<वाक्यविन्यास प्रकाश लैंग = बैट>
:ए
गूंज अनंत लूप
उधर जाओ
</वाक्यविन्यास हाइलाइट>
यहां लूप काफी स्पष्ट है, क्योंकि अंतिम पंक्ति बिना शर्त निष्पादन को पहले वाले को वापस भेजती है।


जावा में एक उदाहरण (प्रोग्रामिंग भाषा)
1980 के दशक की [[बुनियादी प्रोग्रामिंग भाषा|बेसिक प्रोग्रामिंग]] लैंग्वेज में समान उदाहरण:<syntaxhighlight lang="d">
<वाक्यविन्यास प्रकाश लैंग = जावा>
10 PRINT "INFINITE LOOP"
जबकि (सच) {
20 GOTO 10
     System.out.println (अनंत लूप);
</syntaxhighlight>डॉस बैच फ़ाइलों में समान उदाहरण:<syntaxhighlight lang="d">
:A
echo Infinite Loop
goto :A
</syntaxhighlight>यहां लूप अधिक स्पष्ट है, क्योंकि अंतिम पंक्ति बिना शर्त निष्पादन को पहले वाले को वापस भेजती है।जावा (प्रोग्रामिंग लैंग्वेज) में उदाहरण<syntaxhighlight lang="d">
while (true) {
     System.out.println("Infinite Loop");
}
}
</वाक्यविन्यास हाइलाइट>
</syntaxhighlight>[[बोर्न अगेन शैल]] में उदाहरण<syntaxhighlight lang="d">
 
for ((;;)); do
[[बोर्न अगेन शैल]] में एक उदाहरण
echo "Infinite Loop"
<वाक्यविन्यास लैंग = बैश>
done
के लिए ((;;)); करना
</syntaxhighlight>रस्ट (प्रोग्रामिंग लैंग्वेज) में उदाहरण<syntaxhighlight lang="d">
गूंज अनंत लूप
loop {
पूर्ण
     println!("Infinite loop");
</वाक्यविन्यास हाइलाइट>
 
जंग में एक उदाहरण (प्रोग्रामिंग भाषा)
<वाक्यविन्यास प्रकाश लैंग = जंग>
कुंडली {
     Println! (अनंत पाश);
}
}
</वाक्यविन्यास हाइलाइट>
</syntaxhighlight>


==अनजाने अनंत लूप के उदाहरण==
==अपरिचित इनफिनिट लूप के उदाहरण==


===गणितीय त्रुटियाँ===
===गणितीय त्रुटियाँ===
यहाँ [[Visual Basic]] में अनंत लूप का एक उदाहरण दिया गया है:
यहाँ [[Visual Basic|विसुअल बेसिक]] में इनफिनिट लूप का उदाहरण दिया गया है:<syntaxhighlight lang="d">
<syntaxhighlight lang=vb>
dim x as integer
मंद एक्स पूर्णांक के रूप में
do while x < 5
करते हैं जबकि x <5
   x = 1
   एक्स = 1
   x = x + 1
   एक्स = एक्स + 1
loop
कुंडली
</syntaxhighlight>यह ऐसी स्थिति बनाता है जहां <code>x</code>  कभी भी 5 से अधिक नहीं होता है क्योंकि लूप कोड की प्रारंभ में <code>x</code> कों 1 का मान दिया जाता है, इस प्रकार, लूप हमेशा 2 में समाप्त होता है और लूप कभी नहीं टूटता है। इसे <code>x = 1</code>  निर्देश को लूप के बाहर ले जाकर ठीक किया जा सकता है। अनिवार्य रूप से यह इनफिनिट लूप क्या करता है कंप्यूटर को 5 तक पहुंचने तक 1 से 1 जोड़ने के लिए निर्देश देना है। चूंकि 1+1 हमेशा 2 के समान होता है, ऐसा कभी नहीं होता है। कुछ लैंग्वेजेस में, गणितीय प्रतीकों के बारे में प्रोग्रामर का संशय अपरिचित में इनफिनिट लूप का कारण बन सकता है। उदाहरण के लिए, यहाँ C (प्रोग्रामिंग लैंग्वेज) में स्निपेट है:<syntaxhighlight lang="d">
#include <stdio.h>


</वाक्यविन्यास हाइलाइट>
int main(void)
इससे ऐसी स्थिति पैदा हो जाती है कि <code>x</code> लूप कोड की शुरुआत के बाद से कभी भी 5 से अधिक नहीं होगा <code>x</code> 1 का मान दिया जाता है, इस प्रकार, लूप हमेशा 2 में समाप्त होगा और लूप कभी नहीं टूटेगा। इसे स्थानांतरित करके ठीक किया जा सकता है <code>x = 1</code> लूप के बाहर निर्देश। अनिवार्य रूप से यह अनंत लूप क्या करता है एक कंप्यूटर को 5 तक पहुंचने तक 1 से 1 जोड़ने के लिए निर्देश देना है। चूंकि 1+1 हमेशा 2 के बराबर होता है, ऐसा कभी नहीं होगा।
 
कुछ भाषाओं में, गणितीय प्रतीकों के बारे में प्रोग्रामर का भ्रम अनजाने में अनंत लूप का कारण बन सकता है। उदाहरण के लिए, यहाँ C (प्रोग्रामिंग भाषा) में एक स्निपेट है:
<वाक्यविन्यास प्रकाश लैंग = सी>
#शामिल <stdio.h>
 
पूर्णांक मुख्य (शून्य)
{
{
   इंट ए = 0;
   int a = 0;
   जबकि (ए <10) {
   while (a < 10) {
       प्रिंटफ (% डी \ n, ए);
       printf("%d\n", a);
       अगर (ए = 5)
       if (a = 5)
         प्रिंटफ (ए 5 के बराबर है!\n);
         printf("a equals 5!\n");
       ए ++;
       a++;
   }
   }
   वापसी 0;
   return 0;
}
}
</वाक्यविन्यास हाइलाइट>
</syntaxhighlight>अपेक्षित आउटपुट 0 से 9 तक की संख्या है, जिसमें इंटरजेक्टेड "a समान 5!"  5 और 6 के बीच है। चूंकि, लाइन में<code>if (a = 5)</code>ऊपर, प्रोग्रामर ने = (असाइनमेंट) ऑपरेटर को == (समानता परीक्षण) ऑपरेटर के साथ भ्रमित कर दिया है। यह प्रोग्राम में <code>a</code> बिंदु पर 5 का मान असाइन करेगा। इस प्रकार, <code>a</code> कभी भी 10 तक आगे बढ़ने में सक्षम नहीं होता है, और यह लूप समाप्त नहीं हो सकता हैं।
 
अपेक्षित आउटपुट 0 से 9 तक की संख्या है, एक इंटरजेक्टेड 5 के बराबर है! 5 और 6 के बीच। हालांकि, लाइन में<code>if (a = 5)</code>ऊपर, प्रोग्रामर ने = (असाइनमेंट) ऑपरेटर को == (समानता परीक्षण) ऑपरेटर के साथ भ्रमित कर दिया है। इसके बजाय, यह 5 का मान असाइन करेगा <code>a</code> इस बिंदु पर कार्यक्रम में। इस प्रकार, <code>a</code> कभी भी 10 तक आगे नहीं बढ़ पाएगा, और यह लूप समाप्त नहीं हो सकता।


=== राउंडिंग त्रुटियाँ ===
=== राउंडिंग त्रुटियाँ ===
Line 222: Line 192:
{| style="float:right; border: 1px solid grey;"
{| style="float:right; border: 1px solid grey;"
|-
|-
| ''C output on an [[AMD Turion]] processor:''
| ''AMD Turion प्रोसेसर पर C आउटपुट:''
|-  
|-  
|x = 0.10000000149011611938       
|x = 0.10000000149011611938       
Line 250: Line 220:
| ...
| ...
|}
|}
समाप्ति की स्थिति का मूल्यांकन करने में अप्रत्याशित व्यवहार भी इस समस्या का कारण बन सकता है। यहाँ C (प्रोग्रामिंग भाषा) में एक उदाहरण दिया गया है:
समाप्ति की स्थिति का मानांकन करने में अप्रत्याशित व्यवहार भी इस समस्या का कारण बन सकता है। यहाँ C (प्रोग्रामिंग लैंग्वेज) में उदाहरण दिया गया है:<syntaxhighlight lang="d">
 
float x = 0.1;
<वाक्यविन्यास प्रकाश लैंग = सी>
while (x != 1.1) {
फ्लोट एक्स = 0.1;
   printf("x = %22.20f\n", x);
जबकि (एक्स! = 1.1) {
   x += 0.1;
   प्रिंटफ (एक्स =% 22.20f \ n, एक्स);
   एक्स += 0.1;
}
}
</वाक्यविन्यास हाइलाइट>
</syntaxhighlight>कुछ प्रणालियों पर, यह लूप अपेक्षा के अनुरूप दस बार निष्पादित होता है, किन्तु अन्य प्रणालियों पर यह कभी समाप्त नहीं होता है। समस्या यह है कि दो [[तैरनेवाला स्थल|फ्लोटिंग पॉइंट]] मानों की त्रुटिहीन समानता के लिय लूप टर्मिनेटिंग कंडीशन <code>(x!= 1.1)</code>  परीक्षण और जिस तरह से कई कंप्यूटरों में फ्लोटिंग पॉइंट वैल्यू का प्रतिनिधित्व किया जाता है, वह इस परीक्षण को विफल कर देगा, क्योंकि वे मान 0.1 का त्रुटिहीन रूप से प्रतिनिधित्व नहीं कर सकते हैं, इस प्रकार प्रत्येक वेतन वृद्धि (cf. बॉक्स) पर राउंडिंग त्रुटियों का परिचय देते हैं। [[पायथन (प्रोग्रामिंग भाषा)|पायथन (प्रोग्रामिंग लैंग्वेज)]] में भी ऐसा ही हो सकता है:<syntaxhighlight lang="d">
x = 0.1
while x != 1:
    print(x)
    x += 0.1
</syntaxhighlight>समानता या गैर-समानता के परीक्षणों की अप्रत्याशित रूप से विफल होने की संभावना के कारण, फ़्लोटिंग-पॉइंट मानों से निपटने के समय परीक्षण से अधिक या कम से अधिक का उपयोग करना सुरक्षित है। उदाहरण के लिए, यह परीक्षण करने के अतिरिक्त कि क्या <code>x</code> 1.1 के समान है, कोई यह परीक्षण कर सकता है कि क्या <code>(x <= 1.0)</code>, या <code>(x < 1.1)</code> के समान है, जिनमें से कोई भी निश्चित संख्या में पुनरावृत्तियों के पश्चात बाहर निकलना निश्चित होता है। इस विशेष उदाहरण को ठीक करने का अन्य विधि [[पूर्णांक (कंप्यूटर विज्ञान)]] को नियंत्रण प्रवाह के रूप में उपयोग करना होता है, जो किए गए पुनरावृत्तियों की संख्या की गणना करता है।


कुछ प्रणालियों पर, यह लूप अपेक्षा के अनुरूप दस बार निष्पादित होगा, लेकिन अन्य प्रणालियों पर यह कभी समाप्त नहीं होगा। समस्या यह है कि लूप समाप्ति की स्थिति <code>(x != 1.1)</code> दो [[तैरनेवाला स्थल]] मानों की सटीक समानता के लिए परीक्षण, और जिस तरह से कई कंप्यूटरों में फ़्लोटिंग पॉइंट मानों का प्रतिनिधित्व किया जाता है, वह इस परीक्षण को विफल कर देगा, क्योंकि वे मान 0.1 का सटीक रूप से प्रतिनिधित्व नहीं कर सकते हैं, इस प्रकार प्रत्येक वेतन वृद्धि (cf. बॉक्स) पर राउंडिंग त्रुटियों का परिचय देते हैं।
इसी तरह की समस्या प्रायः [[संख्यात्मक विश्लेषण]] में होती है: निश्चित परिणाम की गणना करने के लिए, पुनरावृत्ति का विचार तब तक किया जाता है जब तक कि त्रुटि चुनी हुई सहनशीलता से छोटी नहीं होना चाहिए। चूंकि, पुनरावृत्ति के समय राउंडिंग त्रुटियों के कारण, निर्दिष्ट सहिष्णुता तक कभी नहीं पहुंचा जा सकता है, जिसके परिणामस्वरूप इनफिनिट लूप होता है।
 
[[पायथन (प्रोग्रामिंग भाषा)]] में भी ऐसा ही हो सकता है:
<वाक्यविन्यास लैंग = अजगर>
एक्स = 0.1
जबकि एक्स! = 1:
    प्रिंट (एक्स)
    एक्स += 0.1
</वाक्यविन्यास हाइलाइट>
 
समानता या गैर-समानता के परीक्षणों की अप्रत्याशित रूप से विफल होने की संभावना के कारण, फ़्लोटिंग-पॉइंट मानों से निपटने के दौरान परीक्षण से अधिक या कम से अधिक का उपयोग करना सुरक्षित है। उदाहरण के लिए, परीक्षण के बजाय कि क्या <code>x</code> 1.1 के बराबर है, कोई परीक्षण कर सकता है कि क्या <code>(x <= 1.0)</code>, या <code>(x < 1.1)</code>, जिनमें से कोई भी निश्चित संख्या में पुनरावृत्तियों के बाद बाहर निकलना निश्चित होगा। इस विशेष उदाहरण को ठीक करने का एक अन्य तरीका एक [[पूर्णांक (कंप्यूटर विज्ञान)]] को एक नियंत्रण प्रवाह के रूप में उपयोग करना होगा, जो किए गए पुनरावृत्तियों की संख्या की गणना करता है।
 
इसी तरह की समस्या अक्सर [[संख्यात्मक विश्लेषण]] में होती है: एक निश्चित परिणाम की गणना करने के लिए, एक पुनरावृत्ति का इरादा तब तक किया जाता है जब तक कि त्रुटि एक चुनी हुई सहनशीलता से छोटी न हो। हालांकि, पुनरावृत्ति के दौरान राउंडिंग त्रुटियों के कारण, निर्दिष्ट सहिष्णुता तक कभी नहीं पहुंचा जा सकता है, जिसके परिणामस्वरूप एक अनंत लूप होता है।


== मल्टी-पार्टी लूप ==
== मल्टी-पार्टी लूप ==
एक अनंत लूप कई संस्थाओं के परस्पर क्रिया के कारण हो सकता है। एक सर्वर पर विचार करें जो हमेशा एक त्रुटि संदेश के साथ उत्तर देता है यदि वह अनुरोध को नहीं समझता है। यहां तक ​​​​कि अगर सर्वर के भीतर एक अनंत लूप की कोई संभावना नहीं है, उनमें से दो (ए और बी) वाली प्रणाली अंतहीन रूप से लूप कर सकती है: यदि ए को बी से अज्ञात प्रकार का संदेश प्राप्त होता है, तो ए एक त्रुटि संदेश के साथ बी को उत्तर देता है। ; यदि B त्रुटि संदेश को नहीं समझता है, तो वह A को अपने स्वयं के त्रुटि संदेश के साथ उत्तर देता है; यदि A, B के त्रुटि संदेश को नहीं समझता है, तो वह एक और त्रुटि संदेश भेजता है, इत्यादि।
इनफिनिट लूप कई संस्थाओं के परस्पर क्रिया के कारण हो सकता है। सर्वर पर विचार करें जो हमेशा त्रुटि संदेश के साथ उत्तर देता है यदि वह अनुरोध को नहीं समझता है। यहां तक ​​​​कि यदि सर्वर के अन्दर इनफिनिट लूप की कोई संभावना नहीं है, तो उनमें से दो (A और B) वाली प्रणाली अंतहीन रूप से लूप कर सकती है: यदि A को B से अज्ञात प्रकार का संदेश प्राप्त होता है, तो A त्रुटि संदेश के साथ B को उत्तर देता है। यदि B त्रुटि संदेश को नहीं समझता है, तो वह A को अपने स्वयं के त्रुटि संदेश के साथ उत्तर देता है; यदि A, B के त्रुटि संदेश को नहीं समझता है, तो वह और त्रुटि संदेश भेजता है, और इसी तरह आगे भी होता हैं।


ऐसी स्थिति का एक सामान्य उदाहरण [[ईमेल पाश]] है। ईमेल लूप का एक उदाहरण यह है कि यदि किसी व्यक्ति को बिना उत्तर वाले इनबॉक्स से मेल प्राप्त होता है, लेकिन उनका ऑटो-प्रतिक्रिया चालू है। वे नो रिप्लाई इनबॉक्स का जवाब देंगे, यह ट्रिगर करते हुए यह नो रिप्लाई इनबॉक्स रिस्पांस है। यह उपयोगकर्ता को भेजा जाएगा, जो तब नो-रिप्लाई इनबॉक्स में एक ऑटो रिप्लाई भेजता है, और इसी तरह आगे भी।
ऐसी स्थिति का सामान्य उदाहरण [[ईमेल पाश|ईमेल लूप]] है। ईमेल लूप का उदाहरण यह है कि यदि किसी व्यक्ति को बिना उत्तर वाले इनबॉक्स से मेल प्राप्त होता है, किन्तु उनका ऑटो-प्रतिक्रिया चालू है। वे नो रिप्लाई इनबॉक्स का उत्तर देंगे, यह ट्रिगर करते हुए यह नो रिप्लाई इनबॉक्स रिस्पांस है। यह उपयोगकर्ता को भेजा जाएगा, जो तब नो-रिप्लाई इनबॉक्स में ऑटो रिप्लाई भेजता है, और इसी तरह आगे भी होता हैं।


== छद्म-अनंत लूप ==
== छद्म-इनफिनिट लूप ==
छद्म-अनंत लूप एक ऐसा लूप है जो अनंत दिखाई देता है लेकिन वास्तव में यह बहुत लंबा लूप है।
छद्म-इनफिनिट लूप ऐसा लूप है जो इनफिनिट दिखाई देता है किन्तु वास्तविक में यह बहुत लंबा लूप है।


=== बहुत बड़ी संख्या ===
=== बहुत बड़ी संख्या ===
[[बैश (यूनिक्स शेल)]] में एक उदाहरण:
[[बैश (यूनिक्स शेल)]] में उदाहरण:<syntaxhighlight lang="d">
<वाक्यविन्यास लैंग = बैश>
for x in $(seq 1000000000); do
x के लिए $(seq 1000000000); करना
#loop code
# लूप कोड
done
किया हुआ
</syntaxhighlight>
</वाक्यविन्यास हाइलाइट>


=== असंभव समाप्ति की स्थिति ===
=== असंभव समाप्ति की स्थिति ===
सी (प्रोग्रामिंग भाषा) में लूप के लिए एक उदाहरण:
सी (प्रोग्रामिंग लैंग्वेज) में लूप के लिए उदाहरण:<syntaxhighlight lang="d">
<वाक्यविन्यास प्रकाश लैंग = सी>
unsigned int i;
अहस्ताक्षरित int मैं;
for (i = 1; i != 0; i++) {
के लिए (मैं = 1; मैं! = 0; मैं ++) {
   /* loop code */
   /* लूप कोड */
}
}
</वाक्यविन्यास हाइलाइट>
</syntaxhighlight>ऐसा प्रतीत होता है कि यह अनिश्चित काल तक चलेगा, किन्तु वास्तविक में इसका मान <code>i</code> अंततः <code>unsigned int</code> में संग्रहीत अधिकतम मान तक पहुंच जाएगा  और उस संख्या में 1 जोड़ने से लूप को तोड़ते हुए 0 के आसपास लपेटा जाएगा। <code>i</code> की वास्तविक सीमा उपयोग किए गए प्रणाली और [[संकलक|कंपाइलर]] के विवरण पर निर्भर करता है। [[मनमाना-सटीक अंकगणित|स्वैच्छिक-त्रुटिहीन अंकगणित]] के साथ, यह लूप तब तक जारी रहेगा जब तक कि कंप्यूटर की [[मेमोरी (कंप्यूटर)]] <code>i</code> को होल्ड नहीं कर सकती, यदि <code>i</code> अहस्ताक्षरित पूर्णांक के अतिरिक्त हस्ताक्षरित पूर्णांक था, तो अतिप्रवाह अपरिभाषित होता है। इस स्थिति में, कंपाइलर कोड को इनफिनिट लूप में अनुकूलित कर सकता है।
ऐसा प्रतीत होता है कि यह अनिश्चित काल तक चलेगा, लेकिन वास्तव में इसका मूल्य <code>i</code> अंततः एक में संग्रहीत अधिकतम मूल्य तक पहुंच जाएगा <code>unsigned int</code> और उस संख्या में 1 जोड़ने से लूप टूट जाएगा। की वास्तविक सीमा <code>i</code> उपयोग किए गए सिस्टम और [[संकलक]] के विवरण पर निर्भर करता है। [[मनमाना-सटीक अंकगणित]] के साथ, यह लूप तब तक जारी रहेगा जब तक कि कंप्यूटर की [[मेमोरी (कंप्यूटर)]] अब और नहीं पकड़ सकता <code>i</code>. अगर <code>i</code> एक हस्ताक्षरित पूर्णांक था, एक अहस्ताक्षरित पूर्णांक के बजाय, अतिप्रवाह अपरिभाषित होगा। इस मामले में, संकलक कोड को अनंत लूप में अनुकूलित कर सकता है।
=== इनफिनिट पुनरावर्तन ===
इनफिनिट पुनरावर्तन इनफिनिट लूप का विशेष स्थिति है जो पुनरावर्तन के कारण होता है।


=== अनंत पुनरावर्तन ===
अनुप्रयोगों के लिए विसुअल बेसिक में निम्न उदाहरण [[स्टैक ओवरफ़्लो]] त्रुटि देता है:<syntaxhighlight lang="d">
अनंत पुनरावर्तन अनंत लूप का एक विशेष मामला है जो पुनरावर्तन के कारण होता है।
Sub Test1()
    Call Test1
End Sub
</syntaxhighlight>


अनुप्रयोगों के लिए Visual Basic में निम्न उदाहरण [[स्टैक ओवरफ़्लो]] त्रुटि देता है:
=== कथन का उल्लंघन ===
<वाक्यविन्यास लैंग = वीबी>
<code>while (true)</code>लूप पहली दृष्टि में इनफिनिट दिखता है, किन्तु [[ब्रेक स्टेटमेंट]] या [[वापसी कथन]] के माध्यम से लूप से बचने की विधि हो सकती है।
उप परीक्षण1 ()
[[PHP|पीएचपी]] में उदाहरण:<syntaxhighlight lang="d">
    कॉल टेस्ट1
while (true) {
अंत उप
     if ($foo->bar()) {
</वाक्यविन्यास हाइलाइट>
         return;
 
=== ब्रेक स्टेटमेंट ===
ए<code>while (true)</code>लूप पहली नज़र में अनंत दिखता है, लेकिन [[ब्रेक स्टेटमेंट]] या [[वापसी कथन]] के माध्यम से लूप से बचने का एक तरीका हो सकता है।
[[PHP]] में उदाहरण:
<वाक्यविन्यास लैंग = php>
जबकि (सच) {
     अगर ($ फू-> बार ()) {
         वापसी;
     }
     }
}
}
</वाक्यविन्यास हाइलाइट>
</syntaxhighlight>


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


एल्डर्सन लूप का एक सी-जैसा स्यूडोकोड उदाहरण, जहां कार्यक्रम को उपयोगकर्ता द्वारा दी गई संख्याओं को शून्य तक दिए जाने तक माना जाता है, लेकिन जहां प्रोग्रामर ने गलत ऑपरेटर का उपयोग किया है:
एल्डर्सन लूप का सी-जैसा स्यूडोकोड उदाहरण, जहां कार्यक्रम को उपयोगकर्ता द्वारा दी गई संख्याओं को शून्य तक दिए जाने तक माना जाता है, किन्तु जहां प्रोग्रामर ने गलत ऑपरेटर का उपयोग किया है:<syntaxhighlight lang="d">
<वाक्यविन्यास लैंग = सी>
int sum = 0;
इंट योग = 0;
int i;
int मैं;
while (true) {
जबकि (सच) {
   printf("Input a number to add to the sum or 0 to quit");
   प्रिंटफ (योग में जोड़ने के लिए एक संख्या दर्ज करें या छोड़ने के लिए 0);
   i = getUserInput();
   मैं = getUserInput ();
   if (i * 0) { // if i times 0 is true, add i to the sum. Note: ZERO means FALSE, Non-Zero means TRUE. "i * 0" is ZERO (FALSE)!
   if (i * 0) { // यदि i गुना 0 सत्य है, तो योग में i जोड़ें। Note: ZERO का मतलब FALSE होता है, Non-Zero का मतलब TRUE होता है. i * 0 शून्य (गलत) है!
       sum += i; // sum never changes because (i * 0) is 0 for any i; it would change if we had != in the condition instead of *
       योग + = मैं; // योग कभी नहीं बदलता क्योंकि (i * 0) किसी भी i के लिए 0 है; यह बदल जाएगा अगर हमारे पास != स्थिति में * के बजाय
   }
   }
   अगर (योग> 100) {
   if (sum > 100) {
       तोड़ना; // लूप को समाप्त करें; बाहर निकलने की स्थिति मौजूद है लेकिन कभी नहीं पहुंची है क्योंकि योग में कभी जोड़ा नहीं जाता है
       break;   // terminate the loop; exit condition exists but is never reached because sum is never added to
   }
   }
}
}
</वाक्यविन्यास हाइलाइट>
</syntaxhighlight>इस शब्द को कथित तौर पर प्रोग्रामर (अंतिम नाम एल्डरसन) से अपना नाम मिला, जिसने 1996 में<ref>{{cite web
 
इस शब्द को कथित तौर पर एक प्रोग्रामर (अंतिम नाम एल्डरसन) से अपना नाम मिला, जिसने 1996 में<ref>{{cite web
   |url=https://www.lee-dohm.com/2013/05/24/alderson-loop
   |url=https://www.lee-dohm.com/2013/05/24/alderson-loop
   |title=Alderson loop
   |title=Alderson loop
Line 349: Line 301:
   |archive-url=https://web.archive.org/web/20200619200434/https://www.lee-dohm.com/2013/05/24/alderson-loop/
   |archive-url=https://web.archive.org/web/20200619200434/https://www.lee-dohm.com/2013/05/24/alderson-loop/
   |url-status=live
   |url-status=live
   }}</ref> [[माइक्रोसॉफ्ट पहुंच]] में एक [[मोडल विंडो]] [[संवाद बॉक्स]] को ओके या कैंसल बटन के बिना कोडित किया था, जिससे जब भी बॉक्स आया तो पूरे प्रोग्राम को अक्षम कर दिया।<ref>{{Cite web |url=http://www.catb.org/~esr/jargon/html/A/Alderson-loop.html |title=Alderson Loop |website=[[The Jargon File]], Version 4.4.7 |url-status=live |archive-url=https://web.archive.org/web/20060515053043/http://www.catb.org/~esr/jargon/html/A/Alderson-loop.html |archive-date=2006-05-15 |access-date=2006-05-21}}</ref>
   }}</ref> [[माइक्रोसॉफ्ट पहुंच]] में [[मोडल विंडो]] [[संवाद बॉक्स]] को ओके या कैंसल बटन के बिना कोडित किया था, जिससे जब भी बॉक्स आया तो पूरे प्रोग्राम को अक्षम कर दिया।<ref>{{Cite web |url=http://www.catb.org/~esr/jargon/html/A/Alderson-loop.html |title=Alderson Loop |website=[[The Jargon File]], Version 4.4.7 |url-status=live |archive-url=https://web.archive.org/web/20060515053043/http://www.catb.org/~esr/jargon/html/A/Alderson-loop.html |archive-date=2006-05-15 |access-date=2006-05-21}}</ref>




Line 357: Line 309:
* गतिरोध
* गतिरोध
*डाइवर्जेंस (कंप्यूटर साइंस)
*डाइवर्जेंस (कंप्यूटर साइंस)
* [[कांटा बम]] (एक अनंत लूप दो प्रमुख घटकों में से एक है)
* [[कांटा बम]] (इनफिनिट लूप दो प्रमुख घटकों में है)
*के लिए जाओ
*के लिए जाओ
* [[अनंत प्रतिगमन]]
* [[अनंत प्रतिगमन|इनफिनिट प्रतिगमन]]
*पुनरावृत्ति (कंप्यूटर विज्ञान)
*पुनरावृत्ति (कंप्यूटर विज्ञान)


Line 369: Line 321:
* [http://www.programming-idioms.org/idiom/50/make-an-infinite-loop Make an infinite loop] in several languages, on [http://www.programming-idioms.org/ programming-idioms.org].
* [http://www.programming-idioms.org/idiom/50/make-an-infinite-loop Make an infinite loop] in several languages, on [http://www.programming-idioms.org/ programming-idioms.org].


{{DEFAULTSORT:Infinite Loop}}[[Category: प्रोग्रामिंग में पुनरावृत्ति]] [[Category: प्रत्यावर्तन]] [[Category: सॉफ्टवेयर बग]]  
[[Category:Articles with hatnote templates targeting a nonexistent page|Infinite Loop]]
 
[[Category:Citation Style 1 templates|M]]
 
[[Category:Collapse templates|Infinite Loop]]
 
[[Category:Created On 03/02/2023|Infinite Loop]]
[[Category: Machine Translated Page]]
[[Category:Lua-based templates|Infinite Loop]]
[[Category:Created On 03/02/2023]]
[[Category:Machine Translated Page|Infinite Loop]]
[[Category:Navigational boxes| ]]
[[Category:Navigational boxes without horizontal lists|Infinite Loop]]
[[Category:Pages with empty portal template|Infinite Loop]]
[[Category:Pages with script errors|Infinite Loop]]
[[Category:Pages with syntax highlighting errors|Infinite Loop]]
[[Category:Portal templates with redlinked portals|Infinite Loop]]
[[Category:Short description with empty Wikidata description|Infinite Loop]]
[[Category:Sidebars with styles needing conversion|Infinite Loop]]
[[Category:Template documentation pages|Documentation/doc]]
[[Category:Templates Vigyan Ready|Infinite Loop]]
[[Category:Templates based on the Citation/CS1 Lua module|Infinite Loop]]
[[Category:Templates generating COinS|Cite magazine]]
[[Category:Templates generating microformats|Infinite Loop]]
[[Category:Templates that add a tracking category|Infinite Loop]]
[[Category:Templates that are not mobile friendly|Infinite Loop]]
[[Category:Templates that generate short descriptions|Infinite Loop]]
[[Category:Templates using TemplateData|Infinite Loop]]
[[Category:Wikipedia fully protected templates|Cite magazine]]
[[Category:Wikipedia metatemplates|Infinite Loop]]
[[Category:प्रत्यावर्तन|Infinite Loop]]
[[Category:प्रोग्रामिंग में पुनरावृत्ति|Infinite Loop]]
[[Category:सॉफ्टवेयर बग|Infinite Loop]]

Latest revision as of 12:18, 18 September 2023


कंप्यूटर प्रोग्रामिंग में, अनंत लूप (या इनफिनिट लूप)[1][2] निर्देशों का क्रम है, जो लिखित रूप में, अंतहीन रूप से जारी रहेगा, जब तक कि कोई बाहरी हस्तक्षेप नहीं होता (प्लग खींचो) है। यह इच्छानुरूप हो सकता है।

अवलोकन

यह इससे भिन्न है:

  • एक प्रकार का कंप्यूटर प्रोग्राम जो निर्देश को लगातार तब तक चलाता है जब तक कि इसे बंद या बाधित नहीं किया जाता है।[3]

निम्नलिखित स्यूडोकोड पर विचार करें:

how_many = 0
while is_there_more_data() do
    how_many = how_many + 1
end
display "the number of items counted = " how_many

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

birds = 1
fish = 2
while birds + fish > 1 do
    birds = 3 - birds
    fish = 3 - fish
end

बर्ड्स वैकल्पिक रूप से 1 या 2 होंगे, चूंकि फिश वैकल्पिक रूप से 2 या 1 होगी। लूप तब तक नहीं रुकेगा जब तक कि कोई बाहरी हस्तक्षेप नहीं होता (प्लग को खींचें) हैं।

विवरण

इनफिनिट लूप कंप्यूटर प्रोग्राम में निर्देशों का क्रम है जो या तो लूप के बिना समाप्त होने वाली स्थिति के कारण अंतहीन रूप से लूप करता है,[4] जिसमें कभी भी पूरा नहीं किया जा सकता है या जो लूप को फिर से प्रारंभ करने का कारण बनता है। सहकारी मल्टीटास्किंग के साथ पुराने ऑपरेटिंग प्रणाली में,[5] इनफिनिट लूप सामान्य रूप से पूरे प्रणाली को अनुत्तरदायी बना देते हैं। अब प्रचलित प्रीमेप्टिव मल्टीटास्किंग मॉडल के साथ, इनफिनिट लूप सामान्यतः प्रोग्राम को सभी उपलब्ध प्रोसेसर समय का उपभोग करने का कारण बनते हैं, किन्तु सामान्यतः उपयोगकर्ता द्वारा इसे समाप्त किया जा सकता है। व्यस्त प्रतीक्षा लूप को कभी-कभी इनफिनिट लूप भी कहा जाता है। कंप्यूटर फ्रीजिंग (कंप्यूटिंग) के लिए इनफिनिट लूप संभावित कारण हैं; अन्य में थ्रैशिंग (कंप्यूटर विज्ञान), डेडलॉक और एक्सेस उल्लंघन सम्मिलित हैं।

उद्देश्य बनाम अनपेक्षित लूपिंग

लूपिंग निर्देशों का सेट दोहरा रहा है जब तक कि विशिष्ट शर्त पूरी नहीं हो जाती है। इनफिनिट लूप तब होता है जब लूप की कुछ अंतर्निहित विशेषता के कारण स्थिति कभी पूरी नहीं होती है।

निश्चयपूर्वक लूपिंग

ऐसी कुछ स्थितियाँ होती हैं जब यह वांछित व्यवहार होता है। उदाहरण के लिए, कार्ट्रिज-आधारित गेम कंसोल पर सामान्यतः उनके मुख्य लूप में कोई निकास स्थिति नहीं होती है, क्योंकि कंसोल के बंद होने तक प्रोग्राम के लूप से बाहर निकलने के लिए कोई ऑपरेटिंग प्रणाली नहीं होता है।

आधुनिक इंटरएक्टिव कंप्यूटरों के लिए आवश्यक है कि कंप्यूटर उपयोगकर्ता इनपुट या डिवाइस गतिविधि के लिए लगातार निगरानी रखे जिससे कुछ मौलिक स्तर पर इनफिनिट प्रोसेसिंग आइडल लूप होता है जो डिवाइस के बंद या रीसेट होने तक जारी रहना चाहिए। उदाहरण के लिए, अपोलो गाइडेंस कंप्यूटर में यह बाहरी लूप Exec प्रोग्राम में समाहित था,[6] और यदि कंप्यूटर के पास करने के लिए बिल्कुल कोई दूसरा काम नहीं था तो यह लूप डमी जॉब चलाएगा जो कंप्यूटर गतिविधि सूचक प्रकाश को बंद कर देगा।

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

मल्टी-थ्रेडिंग

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

अपरिचित में लूपिंग

प्रायः, इस शब्द का प्रयोग उन स्थितियों के लिए किया जाता है जब यह अभीष्ट परिणाम नहीं होता है; अर्थात् जब यह सॉफ्टवेयर बग है।[7] नोविस प्रोग्रामरों में ऐसी त्रुटियां सबसे सामान्य हैं, किन्तु अनुभवी प्रोग्रामर द्वारा भी की जा सकती हैं, क्योंकि उनके कारण अधिक सूक्ष्म हो सकते हैं।

सामान्य कारण, उदाहरण के लिए, यह है कि प्रोग्रामर लिंक्ड सूची या ट्री (डेटा संरचना) जैसे डेटा संरचना में नोड्स के अनुक्रम पर पुनरावृति करना चाहता है, प्रत्येक नोड के लिए बार लूप कोड निष्पादित करता है। अनुचित रूप से गठित लिंक डेटा संरचना में संदर्भ लूप बना सकते हैं, जहां नोड दूसरे से लिंक होता है जो पहले अनुक्रम में होता है। यह डेटा संरचना का हिस्सा रिंग (डेटा संरचना) में बनाता है, जिससे सरल कोड हमेशा के लिए लूप हो जाता है।

चूंकि कोड के गहन निरीक्षण से अधिकांश इनफिनिट लूप पाए जा सकते हैं, यह निर्धारित करने के लिए कोई सामान्य विधि नहीं है कि क्या दिया गया प्रोग्राम कभी रुकेगा या हमेशा के लिए चलेगा; यह हॉल्टिंग समस्या की अनिश्चितता है।[8]


व्यवधान

जब तक प्रणाली उत्तरदायी है, इनफिनिट लूप को प्रायः प्रक्रिया को सिग्नल भेजकर बाधित किया जा सकता है (जैसे कि यूनिक्स में सिगिनट (पॉज़िक्स)), या प्रोसेसर के लिए बाधा, जिससे वर्तमान प्रक्रिया को निरस्त किया जा सकता है। इसे टर्मिनल के नियंत्रण-सी कमांड के साथ[9] के साथ या किल (आदेश) कमांड या प्रणाली कॉल का उपयोग करके कार्य प्रबंधक में किया जा सकता है। चूंकि, यह हमेशा काम नहीं करता है, क्योंकि हो सकता है कि प्रक्रिया संकेतों का उत्तर नहीं दे रही हो या प्रोसेसर अबाधित स्थिति में हो सकता है, जैसे कि सिरिक्स कोमा बग ( निर्देश पाइपलाइन में अबाधित निर्देशों को ओवरलैप करने के कारण)। कुछ स्थितियों में सिगकिल जैसे अन्य सिग्नल काम कर सकते हैं, क्योंकि उन्हें प्रतिक्रियात्मक होने के लिए प्रक्रिया की आवश्यकता नहीं होती है, चूंकि अन्य स्थितियों में लूप को प्रणाली शटडाउन से कम नहीं किया जा सकता है।

लैंग्वेज समर्थन

See also: बहाव को नियंत्रित करें

विभिन्न नियंत्रण प्रवाह निर्माणों का उपयोग करके इनफिनिट लूपों को प्रायुक्त किया जा सकता है। सामान्यतः, असंरचित प्रोग्रामिंग में यह जम्प बैक अप (के लिए जाओ) होता है, चूंकि संरचित प्रोग्रामिंग में यह अनिश्चित लूप (चूंकि लूप) होता है जो या तो स्थिति को छोड़ कर या स्पष्ट रूप से इसे while (true) ... के रूप में सेट करके कभी समाप्त नहीं होता है।

कुछ लैंग्वेजेस में इनफिनिट लूप के लिए विशेष रूप से अनिश्चित लूप से शर्त को हटाकर विशेष निर्माण होते हैं। उदाहरणों में एडा (loop ... end loop),[10] फोरट्रान (DO ... END DO), गो (for { ... }), रूबी (loop do ... end), और रस्ट (loop { ... }) सम्मिलित हैं।

निश्चयपूर्वक इनफिनिट किनारों के उदाहरण

साधारण उदाहरण (सी (प्रोग्रामिंग लैंग्वेज) में):

#include <stdio.h>

int main()
{
  for (;;) // or equivalently, while (1)
    ;  
  return 0;
}

इनफिनिट for (;;) का रूप पारंपरिक है, जो सी प्रोग्रामिंग लैंग्वेज के मानक संदर्भ में दिखाई देता है, और प्रायः इसका स्पष्ट रूप से हमेशा के लिए उच्चारण किया जाता है।[11]

यह लूप है जो इनफिनिट लूप को बिना रुके प्रिंट करेगा।

1980 के दशक की बेसिक प्रोग्रामिंग लैंग्वेज में समान उदाहरण:

10 PRINT "INFINITE LOOP"
20 GOTO 10

डॉस बैच फ़ाइलों में समान उदाहरण:

:A
echo Infinite Loop
goto :A

यहां लूप अधिक स्पष्ट है, क्योंकि अंतिम पंक्ति बिना शर्त निष्पादन को पहले वाले को वापस भेजती है।जावा (प्रोग्रामिंग लैंग्वेज) में उदाहरण

while (true) {
    System.out.println("Infinite Loop");
}

बोर्न अगेन शैल में उदाहरण

for ((;;)); do
	echo "Infinite Loop"
done

रस्ट (प्रोग्रामिंग लैंग्वेज) में उदाहरण

loop {
    println!("Infinite loop");
}

अपरिचित इनफिनिट लूप के उदाहरण

गणितीय त्रुटियाँ

यहाँ विसुअल बेसिक में इनफिनिट लूप का उदाहरण दिया गया है:

dim x as integer
do while x < 5
  x = 1
  x = x + 1
loop

यह ऐसी स्थिति बनाता है जहां x कभी भी 5 से अधिक नहीं होता है क्योंकि लूप कोड की प्रारंभ में x कों 1 का मान दिया जाता है, इस प्रकार, लूप हमेशा 2 में समाप्त होता है और लूप कभी नहीं टूटता है। इसे x = 1 निर्देश को लूप के बाहर ले जाकर ठीक किया जा सकता है। अनिवार्य रूप से यह इनफिनिट लूप क्या करता है कंप्यूटर को 5 तक पहुंचने तक 1 से 1 जोड़ने के लिए निर्देश देना है। चूंकि 1+1 हमेशा 2 के समान होता है, ऐसा कभी नहीं होता है। कुछ लैंग्वेजेस में, गणितीय प्रतीकों के बारे में प्रोग्रामर का संशय अपरिचित में इनफिनिट लूप का कारण बन सकता है। उदाहरण के लिए, यहाँ C (प्रोग्रामिंग लैंग्वेज) में स्निपेट है:

#include <stdio.h>

int main(void)
{
   int a = 0;
   while (a < 10) {
      printf("%d\n", a);
      if (a = 5)
         printf("a equals 5!\n");
      a++;
   }
   return 0;
}

अपेक्षित आउटपुट 0 से 9 तक की संख्या है, जिसमें इंटरजेक्टेड "a समान 5!" 5 और 6 के बीच है। चूंकि, लाइन मेंif (a = 5)ऊपर, प्रोग्रामर ने = (असाइनमेंट) ऑपरेटर को == (समानता परीक्षण) ऑपरेटर के साथ भ्रमित कर दिया है। यह प्रोग्राम में a बिंदु पर 5 का मान असाइन करेगा। इस प्रकार, a कभी भी 10 तक आगे बढ़ने में सक्षम नहीं होता है, और यह लूप समाप्त नहीं हो सकता हैं।

राउंडिंग त्रुटियाँ

AMD Turion प्रोसेसर पर C आउटपुट:
x = 0.10000000149011611938
x = 0.20000000298023223877
x = 0.30000001192092895508
x = 0.40000000596046447754
x = 0.50000000000000000000
x = 0.60000002384185791016
x = 0.70000004768371582031
x = 0.80000007152557373047
x = 0.90000009536743164062
x = 1.00000011920928955078
x = 1.10000014305114746094
x = 1.20000016689300537109
...

समाप्ति की स्थिति का मानांकन करने में अप्रत्याशित व्यवहार भी इस समस्या का कारण बन सकता है। यहाँ C (प्रोग्रामिंग लैंग्वेज) में उदाहरण दिया गया है:

float x = 0.1;
while (x != 1.1) {
  printf("x = %22.20f\n", x);
  x += 0.1;
}

कुछ प्रणालियों पर, यह लूप अपेक्षा के अनुरूप दस बार निष्पादित होता है, किन्तु अन्य प्रणालियों पर यह कभी समाप्त नहीं होता है। समस्या यह है कि दो फ्लोटिंग पॉइंट मानों की त्रुटिहीन समानता के लिय लूप टर्मिनेटिंग कंडीशन (x!= 1.1) परीक्षण और जिस तरह से कई कंप्यूटरों में फ्लोटिंग पॉइंट वैल्यू का प्रतिनिधित्व किया जाता है, वह इस परीक्षण को विफल कर देगा, क्योंकि वे मान 0.1 का त्रुटिहीन रूप से प्रतिनिधित्व नहीं कर सकते हैं, इस प्रकार प्रत्येक वेतन वृद्धि (cf. बॉक्स) पर राउंडिंग त्रुटियों का परिचय देते हैं। पायथन (प्रोग्रामिंग लैंग्वेज) में भी ऐसा ही हो सकता है:

x = 0.1
while x != 1:
    print(x)
    x += 0.1

समानता या गैर-समानता के परीक्षणों की अप्रत्याशित रूप से विफल होने की संभावना के कारण, फ़्लोटिंग-पॉइंट मानों से निपटने के समय परीक्षण से अधिक या कम से अधिक का उपयोग करना सुरक्षित है। उदाहरण के लिए, यह परीक्षण करने के अतिरिक्त कि क्या x 1.1 के समान है, कोई यह परीक्षण कर सकता है कि क्या (x <= 1.0), या (x < 1.1) के समान है, जिनमें से कोई भी निश्चित संख्या में पुनरावृत्तियों के पश्चात बाहर निकलना निश्चित होता है। इस विशेष उदाहरण को ठीक करने का अन्य विधि पूर्णांक (कंप्यूटर विज्ञान) को नियंत्रण प्रवाह के रूप में उपयोग करना होता है, जो किए गए पुनरावृत्तियों की संख्या की गणना करता है।

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

मल्टी-पार्टी लूप

इनफिनिट लूप कई संस्थाओं के परस्पर क्रिया के कारण हो सकता है। सर्वर पर विचार करें जो हमेशा त्रुटि संदेश के साथ उत्तर देता है यदि वह अनुरोध को नहीं समझता है। यहां तक ​​​​कि यदि सर्वर के अन्दर इनफिनिट लूप की कोई संभावना नहीं है, तो उनमें से दो (A और B) वाली प्रणाली अंतहीन रूप से लूप कर सकती है: यदि A को B से अज्ञात प्रकार का संदेश प्राप्त होता है, तो A त्रुटि संदेश के साथ B को उत्तर देता है। यदि B त्रुटि संदेश को नहीं समझता है, तो वह A को अपने स्वयं के त्रुटि संदेश के साथ उत्तर देता है; यदि A, B के त्रुटि संदेश को नहीं समझता है, तो वह और त्रुटि संदेश भेजता है, और इसी तरह आगे भी होता हैं।

ऐसी स्थिति का सामान्य उदाहरण ईमेल लूप है। ईमेल लूप का उदाहरण यह है कि यदि किसी व्यक्ति को बिना उत्तर वाले इनबॉक्स से मेल प्राप्त होता है, किन्तु उनका ऑटो-प्रतिक्रिया चालू है। वे नो रिप्लाई इनबॉक्स का उत्तर देंगे, यह ट्रिगर करते हुए यह नो रिप्लाई इनबॉक्स रिस्पांस है। यह उपयोगकर्ता को भेजा जाएगा, जो तब नो-रिप्लाई इनबॉक्स में ऑटो रिप्लाई भेजता है, और इसी तरह आगे भी होता हैं।

छद्म-इनफिनिट लूप

छद्म-इनफिनिट लूप ऐसा लूप है जो इनफिनिट दिखाई देता है किन्तु वास्तविक में यह बहुत लंबा लूप है।

बहुत बड़ी संख्या

बैश (यूनिक्स शेल) में उदाहरण:

for x in $(seq 1000000000); do
#loop code
done

असंभव समाप्ति की स्थिति

सी (प्रोग्रामिंग लैंग्वेज) में लूप के लिए उदाहरण:

unsigned int i;
for (i = 1; i != 0; i++) {
  /* loop code */
}

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

इनफिनिट पुनरावर्तन

इनफिनिट पुनरावर्तन इनफिनिट लूप का विशेष स्थिति है जो पुनरावर्तन के कारण होता है।

अनुप्रयोगों के लिए विसुअल बेसिक में निम्न उदाहरण स्टैक ओवरफ़्लो त्रुटि देता है:

Sub Test1()
    Call Test1
End Sub

कथन का उल्लंघन

while (true)लूप पहली दृष्टि में इनफिनिट दिखता है, किन्तु ब्रेक स्टेटमेंट या वापसी कथन के माध्यम से लूप से बचने की विधि हो सकती है।

पीएचपी में उदाहरण:

while (true) {
    if ($foo->bar()) {
        return;
    }
}

एल्डर्सन लूप

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

एल्डर्सन लूप का सी-जैसा स्यूडोकोड उदाहरण, जहां कार्यक्रम को उपयोगकर्ता द्वारा दी गई संख्याओं को शून्य तक दिए जाने तक माना जाता है, किन्तु जहां प्रोग्रामर ने गलत ऑपरेटर का उपयोग किया है:

int sum = 0;
int i;
while (true) {
   printf("Input a number to add to the sum or 0 to quit");
   i = getUserInput();
   if (i * 0) { // if i times 0 is true, add i to the sum. Note: ZERO means FALSE, Non-Zero means TRUE. "i * 0" is ZERO (FALSE)!
      sum += i; // sum never changes because (i * 0) is 0 for any i; it would change if we had != in the condition instead of *
   }
   if (sum > 100) {
      break;    // terminate the loop; exit condition exists but is never reached because sum is never added to
   }
}

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


यह भी देखें

  • साइकिल का पता लगाना
  • गतिरोध
  • डाइवर्जेंस (कंप्यूटर साइंस)
  • कांटा बम (इनफिनिट लूप दो प्रमुख घटकों में है)
  • के लिए जाओ
  • इनफिनिट प्रतिगमन
  • पुनरावृत्ति (कंप्यूटर विज्ञान)

संदर्भ

  1. ↑ "Endless loop dictionary definition". Archived from the original on 2020-08-01. Retrieved 2020-01-22.
  2. ↑ "What is infinite loop (endless loop)". Archived from the original on 2019-07-15. Retrieved 2020-01-22.
  3. ↑ Denise Caruso (August 16, 1999). "Overload of Hangers-On Creates Bumpy Ride for Internet Stocks". The New York Times. Archived from the original on December 27, 2019. Retrieved December 27, 2019.
  4. ↑ "Codes and Modes: The Character of Documentary Culture". Flow Journal. November 2014. Archived from the original on 2020-08-01. Retrieved 2020-01-23. an infinite loop is one that lacks .. an exit condition
  5. ↑ also known as non-preemptive-multitasking: "Non-preemptive Multitasking". PC Magazine. Archived from the original on July 26, 2019. Retrieved August 15, 2015.
  6. ↑ David Hoag (September 1976). "The History of Apollo On-board Guidance, Navigation, and Control" (PDF). Charles Stark Draper Laboratory. Archived (PDF) from the original on 2016-11-05. Retrieved 2020-01-23.
  7. ↑ "New York Times Crossword Answers". October 13, 2013. Archived from the original on August 2, 2020. Retrieved January 22, 2020. computing .. a defect .. which .. to loop
  8. ↑ "Halting Problem in Theory of Computation". 3 October 2018. Archived from the original on 9 August 2020. Retrieved 22 January 2020.
  9. ↑ "A Buffer Overflow Exploit Against the DameWare Remote Control software". December 19, 2003. Archived from the original on July 24, 2020. Retrieved January 22, 2020. As soon as the command shell is closed with a control-c combination ...
  10. ↑ Ada Programming: Control: Endless Loop
  11. ↑ "Endless loop in C/C++". Archived from the original on 2016-08-03.
  12. ↑ Lee Dohm (May 24, 2013). "Alderson loop". Archived from the original on June 19, 2020. Retrieved January 22, 2020.
  13. ↑ "Alderson Loop". The Jargon File, Version 4.4.7. Archived from the original on 2006-05-15. Retrieved 2006-05-21.


बाहरी कड़ियाँ

Retrieved from ‘https://www.vigyanwiki.in/index.php?title=अनंत_लूप&oldid=258341’