Hvad er uendelig loop?
En uendelig løkke er en løkkekonstruktion, der ikke afslutter løkken og udfører løkken for evigt. Det kaldes også en ubestemt sløjfe eller en endeløs sløjfe. Den producerer enten et kontinuerligt output eller intet output.
Hvornår skal man bruge en uendelig løkke
En uendelig loop er nyttig for de applikationer, der accepterer brugerinput og genererer output kontinuerligt, indtil brugeren forlader applikationen manuelt. I følgende situationer kan denne type loop bruges:
hvordan man deaktiverer udviklertilstand
- Alle operativsystemer kører i en uendelig løkke, da den ikke eksisterer efter at have udført en opgave. Det kommer kun ud af en uendelig løkke, når brugeren manuelt lukker systemet ned.
- Alle servere kører i en uendelig løkke, da serveren reagerer på alle klientanmodninger. Det kommer kun ud af en ubestemt løkke, når administratoren lukker serveren ned manuelt.
- Alle spillene kører også i en uendelig løkke. Spillet vil acceptere brugerens anmodninger, indtil brugeren forlader spillet.
Vi kan skabe en uendelig løkke gennem forskellige løkkestrukturer. Følgende er sløjfestrukturerne, gennem hvilke vi vil definere den uendelige sløjfe:
- for sløjfe
- mens loop
- gør-mens-løkke
- gå til erklæring
- C makroer
Til sløjfe
Lad os se uendelig 'for' sløjfe. Det følgende er definitionen for uendelig til sløjfe:
for(; ;) { // body of the for loop. } Som vi ved, at alle dele af 'for'-løkke er valgfri, og i ovenstående for loop har vi ikke nævnt nogen betingelse; så denne løkke vil udføre uendelige gange.
Lad os forstå gennem et eksempel.
#include int main() { for(;;) { printf('Hello javatpoint'); } return 0; } I ovenstående kode kører vi 'for'-løkken uendeligt mange gange, så 'Hej javatpoint' vil blive vist uendeligt.
Produktion
mens loop
Nu vil vi se, hvordan man opretter en uendelig løkke ved hjælp af en while-løkke. Følgende er definitionen for den uendelige mens-løkke:
while(1) { // body of the loop.. } I ovenstående while-løkke sætter vi '1' inde i loop-tilstanden. Som vi ved, at ethvert heltal, der ikke er nul, repræsenterer den sande betingelse, mens '0' repræsenterer den falske betingelse.
Lad os se på et simpelt eksempel.
#include int main() { int i=0; while(1) { i++; printf('i is :%d',i); } return 0; } I ovenstående kode har vi defineret en while-løkke, som kører uendeligt mange gange, da den ikke indeholder nogen betingelse. Værdien af 'i' vil blive opdateret et uendeligt antal gange.
Produktion
gør..mens loop
Det gøre imens loop kan også bruges til at skabe den uendelige loop. Det følgende er syntaksen til at skabe det uendelige gøre imens sløjfe.
do { // body of the loop.. }while(1); Ovenstående do..while-løkke repræsenterer den uendelige betingelse, da vi giver '1'-værdien inde i loop-tilstanden. Da vi allerede ved, at ikke-nul heltal repræsenterer den sande betingelse, så vil denne løkke køre uendeligt mange gange.
goto erklæring
Vi kan også bruge goto-sætningen til at definere den uendelige løkke.
infinite_loop; // body statements. goto infinite_loop;
I ovenstående kode overfører goto-sætningen kontrollen til den uendelige sløjfe.
Makroer
Vi kan også skabe den uendelige løkke ved hjælp af en makrokonstant. Lad os forstå gennem et eksempel.
#include #define infinite for(;;) int main() { infinite { printf('hello'); } return 0; } I ovenstående kode har vi defineret en makro med navnet 'uendelig', og dens værdi er 'for(;;)'. Når ordet 'uendelig' kommer i et program, vil det blive erstattet med et 'for(;;)'.
Produktion
Indtil nu har vi set forskellige måder at definere en uendelig løkke på. Vi har dog brug for en tilgang til at komme ud af den uendelige løkke. For at komme ud af den uendelige løkke kan vi bruge break-sætningen.
Lad os forstå gennem et eksempel.
#include int main() { char ch; while(1) { ch=getchar(); if(ch=='n') { break; } printf('hello'); } return 0; } I ovenstående kode har vi defineret while-løkken, som vil udføre et uendeligt antal gange, indtil vi trykker på tasten 'n'. Vi har tilføjet 'if'-sætningen inde i while-løkken. 'if'-sætningen indeholder break-nøgleordet, og break-nøgleordet bringer kontrollen ud af løkken.
Utilsigtede uendelige sløjfer
Nogle gange opstår situationen, hvor utilsigtede uendelige loops opstår på grund af fejlen i koden. Hvis vi er nybegyndere, så bliver det meget svært at spore dem. Nedenfor er nogle foranstaltninger til at spore en utilsigtet uendelig løkke:
jdbc
- Vi bør undersøge semikolonerne omhyggeligt. Nogle gange sætter vi semikolon det forkerte sted, hvilket fører til den uendelige løkke.
#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='n'; while(ch='y') { printf('hello'); } return 0; } </pre> <p>In the above code, we use the assignment operator (ch='y') 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>=1;i++) { printf('hello'); } return 0; } </pre> <p>The above code will execute the 'for loop' infinite number of times. As we put the condition (i>=1), which will always be true for every condition, it means that 'hello' 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('x = %f
', 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 ovenstående kode bruger vi tildelingsoperatoren (ch='y'), som fører til udførelse af loop uendeligt mange gange.
- Vi bruger den forkerte sløjfebetingelse, som får sløjfen til at blive eksekveret på ubestemt tid.
#include int main() { for(int i=1;i>=1;i++) { printf('hello'); } return 0; } Ovenstående kode vil udføre 'for loop' et uendeligt antal gange. Som vi sætter betingelsen (i>=1), som altid vil være sand for hver betingelse, betyder det, at 'hej' vil blive udskrevet uendeligt.
- Vi skal være forsigtige, når vi bruger pause nøgleord i den indlejrede løkke, fordi det vil afslutte udførelsen af den nærmeste løkke, 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('x = %f
', 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 ovenstående kode vil løkken køre uendeligt mange gange, da computeren repræsenterer en flydende kommaværdi som en reel værdi. Computeren vil repræsentere værdien af 4.0 som 3.999999 eller 4.000001, så betingelsen (x !=4.0) vil aldrig være falsk. Løsningen på dette problem er at skrive betingelsen som (k<=4.0).< p>
Uendelige sløjfer kan give problemer, hvis det ikke er korrekt kontrolleret eller designet , hvilket fører til overdreven CPU ressourceforbrug og manglende respons i programmer eller systemer. Implementeringsmekanismer at bryde ud af uendelige løkker er afgørende, når det er nødvendigt.
'kruskals algoritme'
Det er tilrådeligt at medtage udgangsforhold indenfor sløjfe for at forhindre utilsigtede uendelige sløjfer. Disse forhold kan baseres på brugerinput , specifikke begivenheder eller flag , eller tidsgrænser . Sløjfen afsluttes ved at inkorporere passende udgangsforhold efter at have opfyldt sit formål eller opfylder specifikke kriterier.
Teknikker til at forhindre uendelige sløjfer:
Selvom uendelige sløjfer kan lejlighedsvis være tiltænkt, er de ofte utilsigtet og kan forårsage program fryser eller går ned . Programmører kan bruge følgende strategier for at undgå utilsigtede uendelige sløjfer:
Tilføj en opsigelsesbetingelse: Sørg for, at løkken har en tilstand, som i sidste ende kan evalueres til falsk , tillader det ende .
Brug en tæller: Etabler et loft over antallet af iterationer og implementer en tæller, der stiger med hver loop-iteration. Selv hvis den krævede betingelse ikke er opfyldt, vil sløjfen i sidste ende komme til en ende .
Indfør et timeout-system: Hvis fristen er nået, sløjfe vil blive stoppet. Brug en timer eller systemfunktioner til at måle den tid, der er gået.
Brug eksterne eller brugerleverede udløsere: Design løkken, så den slutter som reaktion på bestemte brugerinput eller eksterne begivenheder.
I visse tilfælde, uendelige sløjfer kan være bevidst anvendt i specialiserede algoritmer eller operationer på systemniveau . For eksempel bruger realtidssystemer eller indlejrede systemer uendelige sløjfer til at overvåge input eller udføre specifikke opgaver kontinuerligt. Dog skal man passe på at håndtere sådanne sløjfer ordentligt , undgå enhver negativ indvirkning på systemets ydeevne eller reaktionsevne.
Moderne programmeringssprog og udviklingsrammer tilbyder ofte indbyggede mekanismer til at håndtere uendelige sløjfer mere effektivt. For eksempel, Rammer for grafisk brugergrænseflade (GUI). leverer hændelsesdrevne arkitekturer, hvor programmer venter på brugerinput eller systemhændelser, hvilket eliminerer behovet for eksplicitte uendelige loops.
Det er vigtigt at udvise forsigtighed og diskretion ved brug uendelige sløjfer . De bør kun anvendes, når der er en klar og gyldig grund til en ubestemt køresløjfe, og der skal implementeres tilstrækkelige sikkerhedsforanstaltninger for at forhindre enhver negativ indvirkning på programmet eller systemet.
Konklusion:
Afslutningsvis en uendelig løkke i C udgør en looping-konstruktion, der aldrig slutter og bliver ved med at køre for evigt. Forskellige sløjfestrukturer , såsom for loop, while loop, do-while loop, goto statement eller C makroer , kan bruges til at fremstille det. Operativsystemer, servere og videospil anvender alle ofte uendelige loops, da de kræver konstant menneskelig input og output indtil manuel afslutning. På den anden side utilsigtede uendelige sløjfer kan ske på grund af kodefejl, som er svære at identificere, især for nytilkomne.
nøje overvejelse af semikolon, logiske kriterier , og sløjfeterminering krav er påkrævet for at forhindre utilsigtede uendelige sløjfer. Uendelige sløjfer kan skyldes forkert placering af semikolon eller brugen af tildelingsoperatorer i stedet for relationelle operatorer. Falske sløjfebetingelser, der altid evalueres til sande, kan ligeledes resultere i en uendelig løkke . Desuden, da bryde søgeord afslutter kun den nærmeste løkke, skal der udvises forsigtighed, når den bruges i indlejrede løkker. Ydermere, da de kan gøre sløjfetermineringsbetingelsen umulig at opfylde, bør floating-point-fejl tages i betragtning, mens der arbejdes med floating-point-tal.