Unendliche Schleife

Eine unendliche Schleife (auch bekannt als eine endlose Schleife oder unproduktive Schleife) sind eine Folge von Instruktionen in einem Computerprogramm, welche Schleifen endlos, entweder wegen der Schleife, die keine endende Bedingung hat, diejenige habend, die, oder derjenige nie entsprochen werden kann, der die Schleife veranlasst, anzufangen. In älteren Betriebssystemen mit dem Konsumverein haben stark mehrbeanspruchende, unendliche Schleifen normalerweise das komplette System veranlasst, unempfänglich zu werden. Mit dem jetzt überwiegenden Modell der präemptiven Multitasking veranlassen unendliche Schleifen gewöhnlich das Programm, die ganze verfügbare Verarbeiter-Zeit zu verbrauchen, aber können gewöhnlich vom Benutzer begrenzt werden. Beschäftigte Warteschleifen werden auch manchmal "unendliche Schleifen" irreführend genannt. Eine mögliche Ursache eines Computers "das Einfrieren" ist eine unendliche Schleife; andere schließen toten Punkt und Zugriffsübertretungen ein.

Beabsichtigt gegen das unbeabsichtigte Schlingen

Das Schlingen wiederholt eine Reihe von Instruktionen, bis eine spezifische Bedingung entsprochen wird. Eine unendliche Schleife kommt vor, wenn die Bedingung wegen einer innewohnenden Eigenschaft der Schleife nie entsprochen wird.

Das absichtliche Schlingen

Es gibt einige Situationen, wenn das gewünschtes Verhalten ist. Zum Beispiel haben die Spiele auf Patrone-basierten Spielkonsolen normalerweise keine Ausgangsbedingung in ihrer Hauptschleife, weil es kein Betriebssystem für das Programm gibt, um dazu abzugehen; die Schleife-Läufe bis zur Konsole werden davon angetrieben.

Antike Punchcard-Lesen-Einheitsrekordausrüstung würde wörtlich hinken, sobald eine Karte-Verarbeitungsaufgabe vollendet wurde, seitdem es kein Bedürfnis nach der Hardware gab, um fortzusetzen, zu funktionieren, bis ein neuer Stapel von Programm-Karten geladen wurde.

Im Vergleich verlangen moderne interaktive Computer, dass der Computer ständig für den Benutzereingang oder die Gerät-Tätigkeit kontrolliert, so an einem grundsätzlichen Niveau gibt es eine unendliche in einer Prozession gehende müßige Schleife, die weitergehen muss, bis das Gerät abgedreht oder neu gefasst wird.

Moderne Computer halten auch normalerweise die Verarbeiter- oder Hauptplatine-Uhren des Stromkreis-Fahrens nicht, wenn sie abstürzen. Stattdessen weichen sie zu einem Fehlerbedingungsanzeigen Nachrichten an den Maschinenbediener zurück, und gehen in eine unendliche Schleife ein, die auf den Benutzer wartet, um auf einen schnellen entweder zu antworten, um weiterzugehen, oder das Gerät neu zu fassen.

Das unbeabsichtigte Schlingen

Meistenteils wird der Begriff für jene Situationen gebraucht, wenn das nicht das beabsichtigte Ergebnis ist; d. h. wenn das ein Programmfehler ist. In diesem Fall ist es häufig als eine unproduktive Schleife bekannt. Solche Fehler sind unter Anfänger-Programmierern am üblichsten, aber können von erfahrenen Programmierern ebenso gemacht werden, und ihre Ursachen können ziemlich fein sein.

Während die meisten unendlichen Schleifen durch die nahe Inspektion des Codes gefunden werden können, gibt es keine allgemeine Methode zu bestimmen, ob ein gegebenes Programm jemals hinken wird oder für immer laufen wird; das ist die Unentscheidbarkeit des stockenden Problems.

Das einfachste Beispiel (in C):

  1. einschließen

wichtig

{\

während (1) {\

printf ("Unendlicher Loop\n");

}\

}\

</Quelle>

Das ist eine Schleife, die "Unendliche Schleife" ohne Halt drucken wird.

Andere einfache Beispiele:

Ein einfaches Beispiel im GRUNDLEGENDEN:

TUN SIE

SCHLEIFE BIS ZU 0

</Quelle>

Ein ähnliches Beispiel auf der X86 Zusammenbau-Sprache:

Schleife:

; Code, um sich hier zu schlingen

Jmp-Schleife

</Quelle>

Ein drittes Beispiel ist im MS DOS

:A

FANGEN SIE AN

goto: Ein

</Quelle>

Hier ist die Schleife ziemlich offensichtlich, weil die letzte Linie unbedingt Ausführung an das erste zurücksendet.

Ein häufiger Grund besteht zum Beispiel darin, dass der Programmierer vorhat, über eine Sammlung von Sachen wie eine verbundene Liste zu wiederholen, den Schleife-Code einmal für jeden Artikel durchführend. Unpassend gebildete Verbindungen können eine Bezugsschleife in der Liste schaffen, wo sich ein Listenelement zu demjenigen verbindet, das früher in der Liste vorgekommen ist. Das schließt sich einem Teil der Liste in einen Kreis an, das Programm veranlassend, sich für immer zu schlingen.

Mathematische Fehler

Hier ist ein Beispiel einer unendlichen Schleife im Grundlegenden Visuellen:

verdunkeln Sie x als ganze Zahl

tun Sie bis x> 5

x = 1

x = x + 1

Schleife

</Quelle>

Das schafft eine Situation, wo x nie größer sein wird als 5, da am Anfang der Schleife der Code x der Wert von 1, so gegeben wird, wird die Schleife immer in 2 enden, und die Schleife wird nie brechen. Das konnte durch das Bewegen des SATZES x zu 1 Instruktion außerhalb der Schleife befestigt werden. Im Wesentlichen, was diese unendliche Schleife tut, soll einen Computer beauftragen fortzusetzen, 1 zu 1 beizutragen, bis 5 erreicht wird. Seitdem 1+1 ist immer 2 gleich, das wird nie geschehen.

Auf einigen Sprachen kann die Programmierer-Verwirrung über die mathematischen Symbole zu einer unbeabsichtigten unendlichen Schleife führen. Zum Beispiel ist hier ein Schnipsel in C):

einschließen wichtig {\

interne Nummer = 0;

während (a

Die erwartete Produktion ist die Zahlen 0 bis 9, mit einem eingeworfenen "ein Gleichkommen 5!" zwischen 5 und 6. Jedoch, in der Linie, "wenn (= 5) {" oben der Programmierer = (Anweisung) mit == (Gleichheitstest) Maschinenbediener verwechselt hat. Statt dessen wird das den Wert von 5 zu an diesem Punkt im Programm zuteilen. So kann ein Wille nie im Stande sein, zu 10, und diese Schleife vorwärts zu gehen, nicht enden.

Variable Bedienungsfehler

Das unerwartete Verhalten im Auswerten der endenden Bedingung kann auch dieses Problem verursachen. Hier ist ein Beispiel (in C):

lassen Sie x = 0.1 schwimmen;

während (x! = 1.1) {\

printf ("x = %f\n", x);

x = x + 0.1;

}\</Quelle>

Auf einigen Systemen wird diese Schleife zehnmal, wie erwartet, durchführen, aber auf anderen Systemen wird sie nie enden. Das Problem besteht darin, dass die Schleife, die Bedingungstests auf die genaue Gleichheit von zwei Schwimmpunkt-Werten und die Weise begrenzt, Punkt-Werte schwimmen zu lassen, in vielen Computern vertreten wird, wird diesen Test scheitern lassen, weil sie den Wert 1.1 genau nicht vertreten können.

Wegen der Wahrscheinlichkeit von Tests auf die Gleichheit oder Nicht-Gleichheit, die unerwartet scheitert, ist es sicherer, größer zu verwenden - als oder weniger - als Tests wenn, sich mit Schwimmpunkt-Werten befassend. Zum Beispiel anstatt zu prüfen, ob x 1.1 gleich ist, könnte man ob prüfen

Ein ähnliches Problem kommt oft in der numerischen Analyse vor: Um ein bestimmtes Ergebnis zu schätzen, ist eine Wiederholung beabsichtigt, um ausgeführt zu werden, bis der Fehler kleiner ist als eine gewählte Toleranz. Jedoch, wegen Rundungsfehler während der Wiederholung, kann die angegebene Toleranz nie erreicht werden, auf eine unendliche Schleife hinauslaufend.

Mehrparteischleifen

Obwohl unendliche Schleifen in einem einzelnen Programm gewöhnlich leicht sind vorauszusagen, ist eine Schleife, die durch mehrere aufeinander wirkende Entitäten verursacht ist, viel härter vorauszusehen. Denken Sie einen Server, der immer mit einer Fehlermeldung antwortet, wenn es die Bitte nicht versteht. Anscheinend gibt es keine Möglichkeit für eine unendliche Schleife im Server, aber wenn es zwei solche Server (A und B) gibt, und A eine Nachricht des unbekannten Typs von B erhält, dann Antworten mit einer Fehlermeldung zu B, B versteht die Fehlermeldung nicht und antwortet mit seiner eigenen Fehlermeldung, A versteht die Fehlermeldung von B nicht und sendet noch eine andere Fehlermeldung und so weiter ad infinitum. Ein allgemeines Beispiel solcher Situation ist eine E-Mail-Schleife.

Pseudounendliche Schleifen

Eine pseudounendliche Schleife ist eine Schleife, die unendlich scheint, aber wirklich gerade eine sehr lange Schleife ist.

Unmögliche Abbruchbedingung

Ein Beispiel für die Schleife in C:

nicht unterzeichnete interne Nummer i;

für (ich = 1; ich! = 0; ich ++) {\

/* Schleife-Code * /

}\</Quelle>

Es scheint, dass das unbestimmt weitergehen wird, aber tatsächlich wird der Wert dessen schließlich den maximalen Wert erreichen, der in lagerfähig ist, und das Hinzufügen 1 zu dieser Zahl Bildumlauf zu 0 wird, die Schleife brechend. Die wirkliche Grenze dessen hängt von den Details des Systems und verwendeten Bearbeiters ab. Mit der Arithmetik der willkürlichen Präzision würde diese Schleife weitergehen, bis das Gedächtnis des Computers nicht mehr enthalten konnte. Wenn eine unterzeichnete ganze Zahl, aber nicht eine nicht unterzeichnete ganze Zahl wäre, würde Überschwemmung unbestimmt sein. In diesem Fall konnte die Schleife in eine unendliche Schleife optimiert werden.

Unendlicher recursion

Unendlicher recursion, ein spezieller Fall einer unendlichen Schleife, die durch recursion verursacht wird. Das trivialste Beispiel davon ist der Begriff Ω in der Lambda-Rechnung, die unten im Schema gezeigt ist:

(definieren Sie Ω\

(lassen Sie ([ω (Lambda (f) (f f))])

(ω ω)))

</Quelle>

Ω ist ein unendlicher recursion, und hat deshalb keine normale Form. Wenn man strukturellen recursion verwendet, werden unendliche recursions gewöhnlich durch einen fehlenden Grundfall oder durch einen fehlerhaften induktiven Schritt verursacht. Ein Beispiel solch eines fehlerhaften strukturellen recursion:

(definieren Sie (Summe von 1 bis n)

(+ n (resümieren von 1 bis (sub1 n))))

</Quelle>

Die Funktionssumme von 1 bis wird an Stapel-Raum knapp werden, weil der recursion nie anhält — ist es unendlich. Um das Problem zu korrigieren, wird ein Grundfall hinzugefügt.

(definieren Sie (Summe von 1 bis' n)

(cond

[(= n 1) 1]

[sonst (+ n (resümieren von 1 bis' (sub1 n)))]))

</Quelle>

Diese revidierte Funktion wird nur an Stapel-Raum knapp werden, wenn n weniger als 1 ist oder n zu groß ist; Fehlerüberprüfung würde den ersten Fall entfernen. Für die Information über rekursive Funktionen, die nie an Stapel-Raum knapp werden, sieh Schwanz recursion.

Siehe auch: Recursion, für eine abwechselnde Erklärung von unendlichem recursion.

während (wahre) Schleife

Eine Weile (wahre) Schleife sieht unendlich auf den ersten Blick aus, aber kann es eine Weise geben, der Schleife durch eine Brechungsbehauptung oder Rückbehauptung z.B zu entkommen:

während (wahr), {\

wenn ($foo-> Bar ) {\

kehren Sie zurück;

}\

}\</Quelle>

Schleife von Alderson

Eine Schleife von Alderson ist ein Slang oder Jargon-Begriff für eine unendliche Schleife, wo es eine Ausgangsbedingung verfügbar, aber unzugänglich in der aktuellen Durchführung des Codes normalerweise wegen des Programmierer-Fehlers gibt. Diese sind am üblichsten und sichtbar, während sie bei Benutzerschnittstelle-Code die Fehler beseitigen. Wie man betrachtet, sind Programmfehler von Alderson einer der allgemeinsten Typen des Softwareprogrammfehlers.

Ein C ähnliches Pseudocodebeispiel einer Schleife von Alderson, wo das Programm Zahlen summieren soll, die vom Benutzer bis zur Null gegeben sind, wird angeführt, aber wo der Programmierer vergessen hat, die Ausgangsbedingung hinzuzufügen:

während (wahr), {\

printf ("Eingang eine Zahl, um zur Summe oder 0 beizutragen um", aufzuhören);

i = getUserInput;

wenn (ich! = 0) {//, wenn ich der Null nicht gleich bin, wird die Zahl zur Summe hinzugefügt

resümieren Sie + = ich;

}\

//sonst sollte die Klausel für die Null hier, ohne es sein das Programm wird nicht enden.

}\</Quelle>

Der Begriff hat angeblich seinen Namen von einem Programmierer erhalten, der eine modale Nachricht codiert hatte, schließen Microsoft Access ohne irgendeinen eine Taste OK oder Cancel ein, dadurch das komplette Programm unbrauchbar machend, wann auch immer der Kasten heraufgekommen ist.

Siehe auch


Blau-grüne Verbindung / Militärischer Gerichtsbeschluss
Impressum & Datenschutz