TechCodeview

Hva er uendelig loop?

En uendelig løkke er en sløyfekonstruksjon som ikke avslutter løkken og utfører løkken for alltid. Det kalles også en ubestemt løkke eller en endeløs Løkke. Den produserer enten en kontinuerlig utgang eller ingen utgang.

Når du skal bruke en uendelig løkke

En uendelig sløyfe er nyttig for de applikasjonene som aksepterer brukerinndata og genererer utdataene kontinuerlig til brukeren går ut av applikasjonen manuelt. I følgende situasjoner kan denne typen loop brukes:

hvordan deaktiverer utviklermodus

• Alle operativsystemene kjører i en uendelig sløyfe siden den ikke eksisterer etter å ha utført en oppgave. Den kommer ut av en uendelig sløyfe bare når brukeren manuelt slår av systemet.
• Alle serverne kjører i en uendelig sløyfe ettersom serveren svarer på alle klientforespørslene. Den kommer ut av en ubestemt sløyfe bare når administratoren slår av serveren manuelt.
• Alle spillene kjører også i en uendelig loop. Spillet vil godta brukerforespørslene til brukeren går ut av spillet.

Vi kan lage en uendelig løkke gjennom ulike løkkestrukturer. Følgende er løkkestrukturene som vi vil definere den uendelige løkken gjennom:

• for løkke
• mens loop
• gjør-mens-løkke
• gå til uttalelse
• C makroer

For loop

La oss se uendelig 'for' Løkke. Følgende er definisjonen for uendelig for loop:

 for(; ;) { // body of the for loop. } 

Som vi vet at alle delene av 'for'-løkke er valgfrie, og i det ovenstående for loop har vi ikke nevnt noen betingelse; så denne løkken vil kjøre uendelig mange ganger.

La oss forstå gjennom et eksempel.

 #include int main() { for(;;) { printf('Hello javatpoint'); } return 0; } 

I koden ovenfor kjører vi 'for'-løkken uendelig mange ganger, så 'Hei javatpoint' vil vises uendelig.

Produksjon

mens loop

Nå skal vi se hvordan du lager en uendelig løkke ved å bruke en while-løkke. Følgende er definisjonen for den uendelige mens-løkken:

 while(1) { // body of the loop.. } 

I mens-løkken ovenfor setter vi '1' inne i loop-tilstanden. Som vi vet at ethvert heltall som ikke er null representerer den sanne tilstanden mens '0' representerer den falske tilstanden.

La oss se på et enkelt eksempel.

 #include int main() { int i=0; while(1) { i++; printf('i is :%d',i); } return 0; } 

I koden ovenfor har vi definert en while-løkke, som kjører uendelig mange ganger siden den ikke inneholder noen betingelse. Verdien av 'i' vil bli oppdatert et uendelig antall ganger.

Produksjon

gjør.. mens loop

De gjør mens loop kan også brukes til å lage den uendelige loopen. Følgende er syntaksen for å skape det uendelige gjør mens Løkke.

 do { // body of the loop.. }while(1); 

Ovennevnte do..while-løkke representerer den uendelige tilstanden ettersom vi gir '1'-verdien inne i loop-tilstanden. Siden vi allerede vet at ikke-null heltall representerer den sanne tilstanden, så vil denne sløyfen kjøre uendelig mange ganger.

goto uttalelse

Vi kan også bruke goto-setningen til å definere den uendelige løkken.

 infinite_loop; // body statements. goto infinite_loop; 

I koden ovenfor overfører goto-setningen kontrollen til den uendelige sløyfen.

Makroer

Vi kan også lage den uendelige løkken ved hjelp av en makrokonstant. La oss forstå gjennom et eksempel.

 #include #define infinite for(;;) int main() { infinite { printf('hello'); } return 0; } 

I koden ovenfor har vi definert en makro kalt 'uendelig', og verdien er 'for(;;)'. Når ordet 'uendelig' kommer i et program, vil det bli erstattet med et 'for(;;)'.

Produksjon

Til nå har vi sett forskjellige måter å definere en uendelig løkke på. Imidlertid trenger vi en tilnærming for å komme ut av den uendelige sløyfen. For å komme ut av den uendelige løkken kan vi bruke break-setningen.

La oss forstå gjennom et eksempel.

 #include int main() { char ch; while(1) { ch=getchar(); if(ch=='n') { break; } printf('hello'); } return 0; } 

I koden ovenfor har vi definert while-løkken, som vil kjøre et uendelig antall ganger til vi trykker på tasten 'n'. Vi har lagt til 'if'-setningen i while-løkken. 'if'-setningen inneholder nøkkelordet break, og nøkkelordet break bringer kontrollen ut av loopen.

Utilsiktede uendelige løkker

Noen ganger oppstår situasjonen der utilsiktede uendelige løkker oppstår på grunn av feilen i koden. Hvis vi er nybegynnere, blir det veldig vanskelig å spore dem. Nedenfor er noen tiltak for å spore en utilsiktet uendelig sløyfe:

jdbc

• Vi bør undersøke semikolonene nøye. Noen ganger setter vi semikolon på feil sted, noe som fører til den uendelige løkken.

 #include int main() { int i=1; while(i<=10); { printf('%d', i); i++; } return 0; < pre> <p>In the above code, we put the semicolon after the condition of the while loop which leads to the infinite loop. Due to this semicolon, the internal body of the while loop will not execute.</p> <ul> <li>We should check the logical conditions carefully. Sometimes by mistake, we place the assignment operator (=) instead of a relational operator (= =).</li> </ul> <pre> #include int main() { char ch=&apos;n&apos;; while(ch=&apos;y&apos;) { printf(&apos;hello&apos;); } return 0; } </pre> <p>In the above code, we use the assignment operator (ch=&apos;y&apos;) which leads to the execution of loop infinite number of times.</p> <ul> <li>We use the wrong loop condition which causes the loop to be executed indefinitely.</li> </ul> <pre> #include int main() { for(int i=1;i&gt;=1;i++) { printf(&apos;hello&apos;); } return 0; } </pre> <p>The above code will execute the &apos;for loop&apos; infinite number of times. As we put the condition (i&gt;=1), which will always be true for every condition, it means that &apos;hello&apos; will be printed infinitely.</p> <ul> <li>We should be careful when we are using the <strong>break</strong> keyword in the nested loop because it will terminate the execution of the nearest loop, not the entire loop.</li> </ul> <pre> #include int main() { while(1) { for(int i=1;i<=10;i++) { if(i%2="=0)" break; } return 0; < pre> <p>In the above code, the while loop will be executed an infinite number of times as we use the break keyword in an inner loop. This break keyword will bring the control out of the inner loop, not from the outer loop.</p> <ul> <li>We should be very careful when we are using the floating-point value inside the loop as we cannot underestimate the floating-point errors.</li> </ul> <pre> #include int main() { float x = 3.0; while (x != 4.0) { printf(&apos;x = %f
&apos;, x); x += 0.1; } return 0; } </pre> <p>In the above code, the loop will run infinite times as the computer represents a floating-point value as a real value. The computer will represent the value of 4.0 as 3.999999 or 4.000001, so the condition (x !=4.0) will never be false. The solution to this problem is to write the condition as (k<=4.0).< p> <p> <strong> <em>Infinite loops</em> </strong> can cause problems if it is not properly <strong> <em>controlled</em> </strong> or <strong> <em>designed</em> </strong> , leading to excessive <strong> <em>CPU resource consumption</em> </strong> and unresponsiveness in programs or systems. <strong> <em>Implementing mechanisms</em> </strong> to break out of infinite loops is crucial when necessary.</p> <p>It is advisable to include <strong> <em>exit conditions</em> </strong> within the <strong> <em>loop</em> </strong> to prevent unintentional infinite loops. These conditions can be based on <strong> <em>user input</em> </strong> , <strong> <em>specific events or flags</em> </strong> , or <strong> <em>time limits</em> </strong> . The loop will terminate by incorporating appropriate <strong> <em>exit conditions</em> </strong> after fulfilling its purpose or meeting specific criteria.</p> <h2>Techniques for Preventing Infinite Loops:</h2> <p>Although <strong> <em>infinite loops</em> </strong> can occasionally be intended, they are frequently <strong> <em>unintended</em> </strong> and can cause program <strong> <em>freezes</em> </strong> or <strong> <em>crashes</em> </strong> . Programmers can use the following strategies to avoid inadvertent infinite loops:</p> <p> <strong>Add a termination condition:</strong> Make sure the loop has a condition that can ultimately evaluate to <strong> <em>false</em> </strong> , allowing it to <strong> <em>end</em> </strong> .</p> <p> <strong>Employ a counter:</strong> Establish a cap on the number of iterations and implement a counter that increases with each loop iteration. Thus, even if the required condition is not satisfied, the loop will ultimately come to an <strong> <em>end</em> </strong> .</p> <p> <strong>Introduce a timeout system:</strong> If the time limit is reached, the <strong> <em>loop</em> </strong> will be stopped. Use a timer or system functions to measure the amount of time that has passed.</p> <p> <strong>Use external or user-provided triggers:</strong> Design the loop to end in response to certain user input or outside events.</p> <p>In certain cases, <strong> <em>infinite loops</em> </strong> may be intentionally employed in specialized algorithms or <strong> <em>system-level operations</em> </strong> . For instance, real-time systems or embedded systems utilize infinite loops to monitor inputs or execute specific tasks continuously. However, care must be taken to manage such <strong> <em>loops properly</em> </strong> , avoiding any adverse effects on system performance or responsiveness.</p> <p>Modern programming languages and development frameworks often offer built-in mechanisms to handle infinite loops more efficiently. For example, <strong> <em>Graphical user interface (GUI) frameworks</em> </strong> provide event-driven architectures where programs wait for user input or system events, eliminating the need for explicit infinite loops.</p> <p>It is essential to exercise caution and discretion when using <strong> <em>infinite loops</em> </strong> . They should only be employed when there is a clear and valid reason for an indefinite running loop, and adequate safeguards must be implemented to prevent any negative impact on the program or system.</p> <h2>Conclusion:</h2> <p>In conclusion, an <strong> <em>infinite loop</em> </strong> in C constitutes a looping construct that never ends and keeps running forever. Different <strong> <em>loop structures</em> </strong> , such as the <strong> <em>for loop, while loop, do-while loop, goto statement, or C macros</em> </strong> , can be used to produce it. Operating systems, servers, and video games all frequently employ infinite loops since they demand constant human input and output until manual termination. On the other hand, the <strong> <em>unintentional infinite loops</em> </strong> might happen because of code flaws, which are difficult to identify, especially for newcomers.</p> <p>Careful consideration of <strong> <em>semicolons, logical criteria</em> </strong> , and <strong> <em>loop termination</em> </strong> requirements is required to prevent inadvertent infinite loops. Infinite loops can result from improper semicolon placement or the use of assignment operators in place of relational operators. False loop conditions that always evaluate to true may likewise result in an <strong> <em>infinite loop</em> </strong> . Furthermore, since the <strong> <em>break keyword</em> </strong> only ends the closest loop, caution must be used when using it in nested loops. Furthermore, as they may make the loop termination condition impossible to meet, floating-point mistakes should be considered while working with floating-point numbers.</p> <hr></=4.0).<></p></=10;i++)></pre></=10);>

I koden ovenfor bruker vi tilordningsoperatoren (ch='y') som fører til utførelse av loop uendelig mange ganger.

• Vi bruker feil sløyfebetingelse som gjør at sløyfen kjøres på ubestemt tid.

 #include int main() { for(int i=1;i>=1;i++) { printf('hello'); } return 0; } 

Koden ovenfor vil utføre 'for loop' et uendelig antall ganger. Som vi setter betingelsen (i>=1), som alltid vil være sann for hver betingelse, betyr det at 'hei' vil bli skrevet ut i det uendelige.

• Vi bør være forsiktige når vi bruker gå i stykker nøkkelord i den nestede løkken fordi det vil avslutte utførelsen av den nærmeste løkken, ikke hele løkken.

 #include int main() { while(1) { for(int i=1;i<=10;i++) { if(i%2="=0)" break; } return 0; < pre> <p>In the above code, the while loop will be executed an infinite number of times as we use the break keyword in an inner loop. This break keyword will bring the control out of the inner loop, not from the outer loop.</p> <ul> <li>We should be very careful when we are using the floating-point value inside the loop as we cannot underestimate the floating-point errors.</li> </ul> <pre> #include int main() { float x = 3.0; while (x != 4.0) { printf(&apos;x = %f
&apos;, x); x += 0.1; } return 0; } </pre> <p>In the above code, the loop will run infinite times as the computer represents a floating-point value as a real value. The computer will represent the value of 4.0 as 3.999999 or 4.000001, so the condition (x !=4.0) will never be false. The solution to this problem is to write the condition as (k<=4.0).< p> <p> <strong> <em>Infinite loops</em> </strong> can cause problems if it is not properly <strong> <em>controlled</em> </strong> or <strong> <em>designed</em> </strong> , leading to excessive <strong> <em>CPU resource consumption</em> </strong> and unresponsiveness in programs or systems. <strong> <em>Implementing mechanisms</em> </strong> to break out of infinite loops is crucial when necessary.</p> <p>It is advisable to include <strong> <em>exit conditions</em> </strong> within the <strong> <em>loop</em> </strong> to prevent unintentional infinite loops. These conditions can be based on <strong> <em>user input</em> </strong> , <strong> <em>specific events or flags</em> </strong> , or <strong> <em>time limits</em> </strong> . The loop will terminate by incorporating appropriate <strong> <em>exit conditions</em> </strong> after fulfilling its purpose or meeting specific criteria.</p> <h2>Techniques for Preventing Infinite Loops:</h2> <p>Although <strong> <em>infinite loops</em> </strong> can occasionally be intended, they are frequently <strong> <em>unintended</em> </strong> and can cause program <strong> <em>freezes</em> </strong> or <strong> <em>crashes</em> </strong> . Programmers can use the following strategies to avoid inadvertent infinite loops:</p> <p> <strong>Add a termination condition:</strong> Make sure the loop has a condition that can ultimately evaluate to <strong> <em>false</em> </strong> , allowing it to <strong> <em>end</em> </strong> .</p> <p> <strong>Employ a counter:</strong> Establish a cap on the number of iterations and implement a counter that increases with each loop iteration. Thus, even if the required condition is not satisfied, the loop will ultimately come to an <strong> <em>end</em> </strong> .</p> <p> <strong>Introduce a timeout system:</strong> If the time limit is reached, the <strong> <em>loop</em> </strong> will be stopped. Use a timer or system functions to measure the amount of time that has passed.</p> <p> <strong>Use external or user-provided triggers:</strong> Design the loop to end in response to certain user input or outside events.</p> <p>In certain cases, <strong> <em>infinite loops</em> </strong> may be intentionally employed in specialized algorithms or <strong> <em>system-level operations</em> </strong> . For instance, real-time systems or embedded systems utilize infinite loops to monitor inputs or execute specific tasks continuously. However, care must be taken to manage such <strong> <em>loops properly</em> </strong> , avoiding any adverse effects on system performance or responsiveness.</p> <p>Modern programming languages and development frameworks often offer built-in mechanisms to handle infinite loops more efficiently. For example, <strong> <em>Graphical user interface (GUI) frameworks</em> </strong> provide event-driven architectures where programs wait for user input or system events, eliminating the need for explicit infinite loops.</p> <p>It is essential to exercise caution and discretion when using <strong> <em>infinite loops</em> </strong> . They should only be employed when there is a clear and valid reason for an indefinite running loop, and adequate safeguards must be implemented to prevent any negative impact on the program or system.</p> <h2>Conclusion:</h2> <p>In conclusion, an <strong> <em>infinite loop</em> </strong> in C constitutes a looping construct that never ends and keeps running forever. Different <strong> <em>loop structures</em> </strong> , such as the <strong> <em>for loop, while loop, do-while loop, goto statement, or C macros</em> </strong> , can be used to produce it. Operating systems, servers, and video games all frequently employ infinite loops since they demand constant human input and output until manual termination. On the other hand, the <strong> <em>unintentional infinite loops</em> </strong> might happen because of code flaws, which are difficult to identify, especially for newcomers.</p> <p>Careful consideration of <strong> <em>semicolons, logical criteria</em> </strong> , and <strong> <em>loop termination</em> </strong> requirements is required to prevent inadvertent infinite loops. Infinite loops can result from improper semicolon placement or the use of assignment operators in place of relational operators. False loop conditions that always evaluate to true may likewise result in an <strong> <em>infinite loop</em> </strong> . Furthermore, since the <strong> <em>break keyword</em> </strong> only ends the closest loop, caution must be used when using it in nested loops. Furthermore, as they may make the loop termination condition impossible to meet, floating-point mistakes should be considered while working with floating-point numbers.</p> <hr></=4.0).<></p></=10;i++)>

I koden ovenfor vil løkken kjøre uendelig mange ganger ettersom datamaskinen representerer en flyttallsverdi som en reell verdi. Datamaskinen vil representere verdien 4.0 som 3.999999 eller 4.000001, så betingelsen (x !=4.0) vil aldri være usann. Løsningen på dette problemet er å skrive betingelsen som (k<=4.0).< p>

Uendelige løkker kan forårsake problemer hvis det ikke er riktig kontrollert eller designet , som fører til overdreven CPU ressursforbruk og manglende respons i programmer eller systemer. Implementeringsmekanismer å bryte ut av uendelige løkker er avgjørende når det er nødvendig.

'kruskals algoritme'

Det er lurt å inkludere utgangsforhold innen Løkke for å forhindre utilsiktede uendelige løkker. Disse forholdene kan baseres på brukerinnspill , spesifikke hendelser eller flagg , eller tidsbegrensninger . Sløyfen vil avsluttes ved å innlemme passende utgangsforhold etter å ha oppfylt formålet eller oppfylle spesifikke kriterier.

Teknikker for å forhindre uendelige løkker:

Selv om uendelige løkker kan av og til være ment, de er ofte utilsiktet og kan forårsake program fryser eller krasjer . Programmerere kan bruke følgende strategier for å unngå utilsiktede uendelige løkker:

Legg til en oppsigelsesbetingelse: Sørg for at løkken har en tilstand som til slutt kan evalueres til falsk , tillater det slutt .

Bruk en teller: Etabler et tak på antall iterasjoner og implementer en teller som øker med hver loop-iterasjon. Således, selv om den nødvendige betingelsen ikke er oppfylt, vil løkken til slutt komme til en slutt .

Introduser et tidsavbruddssystem: Hvis fristen er nådd, Løkke vil bli stoppet. Bruk en timer eller systemfunksjoner for å måle hvor lang tid som har gått.

Bruk eksterne eller brukerleverte utløsere: Design sløyfen slik at den avsluttes som svar på visse brukerinnspill eller eksterne hendelser.

I visse tilfeller, uendelige løkker kan være med vilje brukt i spesialiserte algoritmer eller operasjoner på systemnivå . For eksempel bruker sanntidssystemer eller innebygde systemer uendelige løkker for å overvåke innganger eller utføre spesifikke oppgaver kontinuerlig. Imidlertid må man passe på å håndtere slike løkker skikkelig , unngå negative effekter på systemytelse eller reaksjonsevne.

Moderne programmeringsspråk og utviklingsrammeverk tilbyr ofte innebygde mekanismer for å håndtere uendelige løkker mer effektivt. For eksempel, Rammer for grafisk brukergrensesnitt (GUI). gi hendelsesdrevne arkitekturer der programmer venter på brukerinndata eller systemhendelser, og eliminerer behovet for eksplisitte uendelige løkker.

Det er viktig å utvise forsiktighet og skjønn ved bruk uendelige løkker . De bør bare brukes når det er en klar og gyldig grunn for en ubestemt løpende sløyfe, og tilstrekkelige sikkerhetstiltak må implementeres for å forhindre negativ innvirkning på programmet eller systemet.

Konklusjon:

Avslutningsvis, en uendelig løkke i C utgjør en looping-konstruksjon som aldri tar slutt og fortsetter å løpe for alltid. Annerledes løkkestrukturer , slik som for loop, while loop, do-while loop, goto statement eller C makroer , kan brukes til å produsere den. Operativsystemer, servere og videospill bruker alle ofte uendelige løkker siden de krever konstant menneskelig input og output til manuell avslutning. På den annen side utilsiktede uendelige løkker kan skje på grunn av kodefeil, som er vanskelige å identifisere, spesielt for nykommere.

Nøye vurdering av semikolon, logiske kriterier , og sløyfeavslutning Det kreves krav for å forhindre utilsiktede uendelige løkker. Uendelige løkker kan skyldes feil plassering av semikolon eller bruk av tilordningsoperatorer i stedet for relasjonsoperatorer. Falske sløyfeforhold som alltid evalueres til sanne kan likeledes resultere i en uendelig løkke . Videre, siden bryte søkeord avslutter kun den nærmeste løkken, det må utvises forsiktighet ved bruk i nestede løkker. Videre, siden de kan gjøre sløyfetermineringsbetingelsen umulig å oppfylle, bør flytende kommafeil vurderes når du arbeider med flyttall.