Qu’est-ce que la boucle infinie ?

Une boucle infinie est une construction en boucle qui ne termine pas la boucle et exécute la boucle pour toujours. On l'appelle aussi un indéfini boucle ou un sans fin boucle. Soit il produit une sortie continue, soit aucune sortie.

Quand utiliser une boucle infinie

Une boucle infinie est utile pour les applications qui acceptent l'entrée de l'utilisateur et génèrent la sortie en continu jusqu'à ce que l'utilisateur quitte manuellement l'application. Dans les situations suivantes, ce type de boucle peut être utilisé :

: en java

• Tous les systèmes d'exploitation fonctionnent dans une boucle infinie car elle n'existe pas après avoir effectué une tâche. Il ne sort d'une boucle infinie que lorsque l'utilisateur arrête manuellement le système.
• Tous les serveurs fonctionnent dans une boucle infinie car le serveur répond à toutes les demandes des clients. Il ne sort d'une boucle indéfinie que lorsque l'administrateur arrête le serveur manuellement.
• Tous les jeux fonctionnent également en boucle infinie. Le jeu acceptera les demandes de l'utilisateur jusqu'à ce que l'utilisateur quitte le jeu.

Nous pouvons créer une boucle infinie à travers diverses structures de boucle. Voici les structures de boucle à travers lesquelles nous définirons la boucle infinie :

• pour la boucle
• boucle while
• faire une boucle en attendant
• aller à la déclaration
• Macro C

Pour la boucle

Voyons le infini 'pour' boucle. Voici la définition du infini pour la boucle :

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

Comme nous savons que toutes les parties du boucle 'pour' sont facultatifs, et dans la boucle for ci-dessus, nous n'avons mentionné aucune condition ; donc, cette boucle s'exécutera des temps infinis.

Comprenons à travers un exemple.

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

Dans le code ci-dessus, nous exécutons la boucle « for » un nombre infini de fois, donc 'Bonjour Javatpoint' sera affiché à l’infini.

Sortir

boucle while

Nous allons maintenant voir comment créer une boucle infinie à l'aide d'une boucle while. Voici la définition de la boucle while infinie :

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

Dans la boucle while ci-dessus, nous mettons « 1 » dans la condition de la boucle. Comme nous le savons, tout entier non nul représente la vraie condition tandis que « 0 » représente la fausse condition.

Regardons un exemple simple.

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

Dans le code ci-dessus, nous avons défini une boucle while, qui s'exécute un nombre infini de fois car elle ne contient aucune condition. La valeur de « i » sera mise à jour un nombre infini de fois.

Sortir

faire..pendant la boucle

Le faire pendant La boucle peut également être utilisée pour créer la boucle infinie. Voici la syntaxe pour créer l'infini faire pendant boucle.

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

La boucle do..while ci-dessus représente la condition infinie car nous fournissons la valeur « 1 » à l’intérieur de la condition de boucle. Comme nous savons déjà qu'un entier non nul représente la vraie condition, cette boucle s'exécutera donc un nombre infini de fois.

aller à la déclaration

Nous pouvons également utiliser l'instruction goto pour définir la boucle infinie.

 infinite_loop; // body statements. goto infinite_loop; 

Dans le code ci-dessus, l'instruction goto transfère le contrôle vers la boucle infinie.

Macro

liste comparable

On peut également créer la boucle infinie à l’aide d’une macro constante. Comprenons à travers un exemple.

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

Dans le code ci-dessus, nous avons défini une macro nommée « infinie » et sa valeur est « for(;;) ». Chaque fois que le mot « infini » apparaît dans un programme, il sera remplacé par un « for(;;) ».

Sortir

Jusqu’à présent, nous avons vu différentes manières de définir une boucle infinie. Cependant, nous avons besoin d’une certaine approche pour sortir de la boucle infinie. Afin de sortir de la boucle infinie, on peut utiliser l’instruction break.

Comprenons à travers un exemple.

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

Dans le code ci-dessus, nous avons défini la boucle while, qui s'exécutera un nombre infini de fois jusqu'à ce que nous appuyions sur la touche 'n'. Nous avons ajouté l'instruction « if » dans la boucle while. L'instruction 'if' contient le mot-clé break, et le mot-clé break fait sortir le contrôle de la boucle.

Boucles infinies involontaires

Parfois, il arrive que des boucles infinies involontaires se produisent en raison d'un bug dans le code. Si nous sommes débutants, il devient alors très difficile de les retrouver. Voici quelques mesures pour tracer une boucle infinie involontaire :

• Nous devrions examiner attentivement les points-virgules. Parfois, nous mettons le point-virgule au mauvais endroit, ce qui conduit à une boucle infinie.

 #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);>

Dans le code ci-dessus, nous utilisons l'opérateur d'affectation (ch='y') qui conduit à l'exécution d'une boucle un nombre infini de fois.

• Nous utilisons une mauvaise condition de boucle, ce qui entraîne l'exécution de la boucle indéfiniment.

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

Le code ci-dessus exécutera la « boucle for » un nombre infini de fois. Comme nous mettons la condition (i>=1), qui sera toujours vraie pour chaque condition, cela signifie que « bonjour » sera imprimé à l'infini.

• Nous devons être prudents lorsque nous utilisons le casser mot-clé dans la boucle imbriquée car il mettra fin à l’exécution de la boucle la plus proche, et non de la boucle entière.

 #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++)>

Dans le code ci-dessus, la boucle s'exécutera un temps infini car l'ordinateur représente une valeur à virgule flottante comme une valeur réelle. L'ordinateur représentera la valeur de 4,0 comme 3,999999 ou 4,000001, donc la condition (x !=4,0) ne sera jamais fausse. La solution à ce problème est d’écrire la condition sous la forme (k<=4.0).< p>

Boucles infinies peut causer des problèmes s'il n'est pas correctement contrôlé ou conçu , conduisant à un excès Consommation des ressources CPU et le manque de réponse des programmes ou des systèmes. Mécanismes de mise en œuvre sortir des boucles infinies est crucial lorsque cela est nécessaire.

Il est conseillé d'inclure conditions de sortie au sein de boucle pour éviter les boucles infinies involontaires. Ces conditions peuvent être fondées sur entrée de l'utilisateur , événements ou drapeaux spécifiques , ou délais . La boucle se terminera en incorporant les conditions de sortie après avoir rempli son objectif ou répondu à des critères spécifiques.

Techniques pour éviter les boucles infinies :

Bien que boucles infinies peuvent parfois être prévus, ils sont fréquemment involontaire et peut provoquer un programme se fige ou crash . Les programmeurs peuvent utiliser les stratégies suivantes pour éviter les boucles infinies accidentelles :

Ajoutez une condition de résiliation : Assurez-vous que la boucle a une condition qui peut finalement être évaluée à FAUX , lui permettant de fin .

Utiliser un compteur : Établissez un plafond sur le nombre d’itérations et implémentez un compteur qui augmente à chaque itération de boucle. Ainsi, même si la condition requise n’est pas satisfaite, la boucle finira par aboutir à un point final. fin .

Introduire un système de timeout : Si le délai est atteint, le boucle sera arrêté. Utilisez une minuterie ou des fonctions système pour mesurer le temps écoulé.

Utilisez des déclencheurs externes ou fournis par l'utilisateur : Concevez la boucle pour qu'elle se termine en réponse à certaines entrées de l'utilisateur ou à des événements extérieurs.

fichier d'extension java

Dans certains cas, boucles infinies peut être intentionnellement utilisé dans des algorithmes spécialisés ou opérations au niveau du système . Par exemple, les systèmes en temps réel ou les systèmes embarqués utilisent des boucles infinies pour surveiller les entrées ou exécuter des tâches spécifiques en continu. Il faut toutefois veiller à gérer de tels boucle correctement , évitant ainsi tout effet néfaste sur les performances ou la réactivité du système.

Les langages de programmation et les cadres de développement modernes offrent souvent des mécanismes intégrés pour gérer plus efficacement les boucles infinies. Par exemple, Cadres d'interface utilisateur graphique (GUI) fournir des architectures basées sur les événements dans lesquelles les programmes attendent les entrées de l'utilisateur ou les événements système, éliminant ainsi le besoin de boucles infinies explicites.

Il est essentiel de faire preuve de prudence et de discrétion lors de l'utilisation boucles infinies . Ils ne doivent être utilisés que lorsqu'il existe une raison claire et valable pour une boucle en cours d'exécution indéfinie, et des garanties adéquates doivent être mises en œuvre pour éviter tout impact négatif sur le programme ou le système.

Conclusion:

En conclusion, un boucle infinie en C constitue une construction en boucle qui ne se termine jamais et continue de fonctionner pour toujours. Différent structures en boucle , comme le boucle for, boucle while, boucle do-while, instruction goto ou macros C , peut être utilisé pour le produire. Les systèmes d'exploitation, les serveurs et les jeux vidéo utilisent tous fréquemment des boucles infinies car ils exigent une entrée et une sortie humaines constantes jusqu'à leur terminaison manuelle. D'un autre côté, le boucles infinies involontaires Cela peut se produire en raison de failles de code, difficiles à identifier, en particulier pour les nouveaux arrivants.

Un examen attentif de points-virgules, critères logiques , et terminaison de boucle Des exigences sont requises pour éviter les boucles infinies par inadvertance. Des boucles infinies peuvent résulter d'un placement inapproprié de points-virgules ou de l'utilisation d'opérateurs d'affectation à la place d'opérateurs relationnels. Des conditions de boucle fausses qui sont toujours évaluées à vrai peuvent également entraîner un boucle infinie . De plus, puisque le casser le mot-clé ne termine que la boucle la plus proche, il faut faire preuve de prudence lors de son utilisation dans des boucles imbriquées. De plus, comme elles peuvent rendre impossible le respect de la condition de fin de boucle, les erreurs de virgule flottante doivent être prises en compte lorsque vous travaillez avec des nombres à virgule flottante.