अनंत लूप

This article is about प्रोग्रामिंग शब्द. For इस शब्द के नाम पर सड़क, see अनंत लूप (सड़क). For माइकल एस मेलोन की पुस्तक, see अनंत लूप (पुस्तक).

"अंतहीन लूप" redirects here. For ईको शिमामिया द्वारा ईपी, see अंतहीन लूप.

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

सिंहावलोकन

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

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

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

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

अंत

गिने गए आइटमों की संख्या प्रदर्शित करें = how_many </वाक्यविन्यास हाइलाइट>

जब तक इसे रोका या बाधित नहीं किया गया तब तक वही निर्देश लगातार चलाए गए। . . फ़ंक्शन is_there_more_data द्वारा किसी बिंदु पर लौटाए गए FALSE द्वारा।

इसके विपरीत, निम्न लूप अपने आप समाप्त नहीं होगा:

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

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

विवरण

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

इरादा बनाम अनपेक्षित लूपिंग

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

जानबूझकर लूपिंग

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

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

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

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

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

अनजाने में लूपिंग

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

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

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

रुकावट

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

भाषा समर्थन

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

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

कुछ भाषाओं में अनंत लूप के लिए विशेष निर्माण होते हैं, आमतौर पर अनिश्चित लूप से स्थिति को छोड़ कर। उदाहरणों में शामिल हैं एडा (loop ... end loop), फोरट्रान (DO ... END DO), जाना (for { ... }), माणिक (loop do ... end), और जंग (loop { ... }).

जानबूझकर अनंत छोरों के उदाहरण

एक साधारण उदाहरण (सी (प्रोग्रामिंग भाषा) में):

#include <stdio.h>

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

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

1980 के दशक की बुनियादी प्रोग्रामिंग भाषा में एक समान उदाहरण: <वाक्यविन्यास लैंग = जीडब्ल्यूबेसिक> 10 अनंत लूप प्रिंट करें 20 गोटो 10 </वाक्यविन्यास हाइलाइट>

डॉस बैच फ़ाइलों में एक समान उदाहरण: <वाक्यविन्यास प्रकाश लैंग = बैट>

ए

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

जावा में एक उदाहरण (प्रोग्रामिंग भाषा) <वाक्यविन्यास प्रकाश लैंग = जावा> जबकि (सच) {

   System.out.println (अनंत लूप);

} </वाक्यविन्यास हाइलाइट>

बोर्न अगेन शैल में एक उदाहरण <वाक्यविन्यास लैंग = बैश> के लिए ((;;)); करना गूंज अनंत लूप पूर्ण </वाक्यविन्यास हाइलाइट>

जंग में एक उदाहरण (प्रोग्रामिंग भाषा) <वाक्यविन्यास प्रकाश लैंग = जंग> कुंडली {

   Println! (अनंत पाश);

} </वाक्यविन्यास हाइलाइट>

अनजाने अनंत लूप के उदाहरण

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

यहाँ Visual Basic में अनंत लूप का एक उदाहरण दिया गया है: <syntaxhighlight lang=vb> मंद एक्स पूर्णांक के रूप में करते हैं जबकि x <5

 एक्स = 1
 एक्स = एक्स + 1

कुंडली

</वाक्यविन्यास हाइलाइट> इससे ऐसी स्थिति पैदा हो जाती है कि x लूप कोड की शुरुआत के बाद से कभी भी 5 से अधिक नहीं होगा x 1 का मान दिया जाता है, इस प्रकार, लूप हमेशा 2 में समाप्त होगा और लूप कभी नहीं टूटेगा। इसे स्थानांतरित करके ठीक किया जा सकता है x = 1 लूप के बाहर निर्देश। अनिवार्य रूप से यह अनंत लूप क्या करता है एक कंप्यूटर को 5 तक पहुंचने तक 1 से 1 जोड़ने के लिए निर्देश देना है। चूंकि 1+1 हमेशा 2 के बराबर होता है, ऐसा कभी नहीं होगा।

कुछ भाषाओं में, गणितीय प्रतीकों के बारे में प्रोग्रामर का भ्रम अनजाने में अनंत लूप का कारण बन सकता है। उदाहरण के लिए, यहाँ C (प्रोग्रामिंग भाषा) में एक स्निपेट है: <वाक्यविन्यास प्रकाश लैंग = सी>

1. शामिल <stdio.h>

पूर्णांक मुख्य (शून्य) {

  इंट ए = 0;
  जबकि (ए <10) {
     प्रिंटफ (% डी \ n, ए);
     अगर (ए = 5)
        प्रिंटफ (ए 5 के बराबर है!\n);
     ए ++;
  }
  वापसी 0;

} </वाक्यविन्यास हाइलाइट>

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

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

C output on an AMD Turion processor:

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 (प्रोग्रामिंग भाषा) में एक उदाहरण दिया गया है:

<वाक्यविन्यास प्रकाश लैंग = सी> फ्लोट एक्स = 0.1; जबकि (एक्स! = 1.1) {

 प्रिंटफ (एक्स =% 22.20f \ n, एक्स);
 एक्स += 0.1;

} </वाक्यविन्यास हाइलाइट>

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

पायथन (प्रोग्रामिंग भाषा) में भी ऐसा ही हो सकता है: <वाक्यविन्यास लैंग = अजगर> एक्स = 0.1 जबकि एक्स! = 1:

   प्रिंट (एक्स)
   एक्स += 0.1

</वाक्यविन्यास हाइलाइट>

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

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

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

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

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

छद्म-अनंत लूप

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

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

बैश (यूनिक्स शेल) में एक उदाहरण: <वाक्यविन्यास लैंग = बैश> x के लिए $(seq 1000000000); करना

1. लूप कोड

किया हुआ </वाक्यविन्यास हाइलाइट>

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

सी (प्रोग्रामिंग भाषा) में लूप के लिए एक उदाहरण: <वाक्यविन्यास प्रकाश लैंग = सी> अहस्ताक्षरित int मैं; के लिए (मैं = 1; मैं! = 0; मैं ++) {

 /* लूप कोड */

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

अनंत पुनरावर्तन

अनंत पुनरावर्तन अनंत लूप का एक विशेष मामला है जो पुनरावर्तन के कारण होता है।

अनुप्रयोगों के लिए Visual Basic में निम्न उदाहरण स्टैक ओवरफ़्लो त्रुटि देता है: <वाक्यविन्यास लैंग = वीबी> उप परीक्षण1 ()

   कॉल टेस्ट1

अंत उप </वाक्यविन्यास हाइलाइट>

ब्रेक स्टेटमेंट

एwhile (true)लूप पहली नज़र में अनंत दिखता है, लेकिन ब्रेक स्टेटमेंट या वापसी कथन के माध्यम से लूप से बचने का एक तरीका हो सकता है। PHP में उदाहरण: <वाक्यविन्यास लैंग = php> जबकि (सच) {

   अगर ($ फू-> बार ()) {
       वापसी;
   }

} </वाक्यविन्यास हाइलाइट>

एल्डर्सन लूप

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

एल्डर्सन लूप का एक सी-जैसा स्यूडोकोड उदाहरण, जहां कार्यक्रम को उपयोगकर्ता द्वारा दी गई संख्याओं को शून्य तक दिए जाने तक माना जाता है, लेकिन जहां प्रोग्रामर ने गलत ऑपरेटर का उपयोग किया है: <वाक्यविन्यास लैंग = सी> इंट योग = 0; int मैं; जबकि (सच) {

  प्रिंटफ (योग में जोड़ने के लिए एक संख्या दर्ज करें या छोड़ने के लिए 0);
  मैं = getUserInput ();
  if (i * 0) { // यदि i गुना 0 सत्य है, तो योग में i जोड़ें। Note: ZERO का मतलब FALSE होता है, Non-Zero का मतलब TRUE होता है. i * 0 शून्य (गलत) है!
     योग + = मैं; // योग कभी नहीं बदलता क्योंकि (i * 0) किसी भी i के लिए 0 है; यह बदल जाएगा अगर हमारे पास != स्थिति में * के बजाय
  }
  अगर (योग> 100) {
     तोड़ना; // लूप को समाप्त करें; बाहर निकलने की स्थिति मौजूद है लेकिन कभी नहीं पहुंची है क्योंकि योग में कभी जोड़ा नहीं जाता है
  }

} </वाक्यविन्यास हाइलाइट>

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

यह भी देखें

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

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

• Make an infinite loop in several languages, on programming-idioms.org.