In der Informatik beziehen sich Kontrollfluss (oder wechselweise, Fluss der Kontrolle) auf die Ordnung, in der die individuellen Erklärungen, Instruktionen oder Funktionsanrufe einer Befehlsform oder eines Aussageprogramms durchgeführt oder bewertet werden.

Innerhalb einer befehlenden Programmiersprache ist eine Kontrollfluss-Behauptung eine Behauptung, deren Ausführung auf eine Wahl hinausläuft, die wird macht, betreffs welchen von zwei oder mehr Pfaden gefolgt werden sollte. Für nichtstrenge funktionelle Sprachen bestehen Funktionen und Sprachkonstruktionen, um dasselbe Ergebnis zu erreichen, aber sie werden Kontrollfluss-Behauptungen nicht notwendigerweise genannt.

Die Arten von durch verschiedene Sprachen unterstützten Kontrollfluss-Behauptungen ändern sich, aber können durch ihre Wirkung kategorisiert werden:

• Verlängerung an einer verschiedenen Behauptung (vorbehaltloser Zweig oder Sprung),
• die Durchführung einer Reihe von Behauptungen nur, wenn etwas Bedingung (Wahl - d. h., bedingter Zweig), entsprochen wird
• eine Reihe der Behauptungsnull oder mehr Male bis durchführend, wird etwas Bedingung (d. h., Schleife - dasselbe als bedingter Zweig), entsprochen
• eine Reihe entfernter Behauptungen durchführend, nach denen der Fluss der Kontrolle gewöhnlich (Unterprogramme, Koroutinen und Verlängerungen), zurückkehrt
• das Aufhören des Programms, das Verhindern weiterer Ausführung (vorbehaltloser Halt).

Unterbrechungen und Signale sind auf niedriger Stufe Mechanismen, die den Fluss der Kontrolle in einem Weg verändern können, der einem Unterprogramm ähnlich ist, aber gewöhnlich als eine Antwort auf einen Außenstimulus oder Ereignis vorkommen (der asynchron vorkommen kann), aber nicht die Ausführung einer 'Reihen'-Kontrollfluss-Behauptung. Das Selbständern des Codes kann auch verwendet werden, um Kontrollfluss seine Nebenwirkungen zu betreffen, aber ist mit keiner ausführlichen Kontrollfluss-Behauptung (eine Ausnahme gewöhnlich verbunden, die das VERÄNDERN Verb im COBOL ist).

Am Niveau der Maschine oder Zusammenbau-Sprache arbeiten Kontrollfluss-Instruktionen gewöhnlich durch das Ändern des Programm-Schalters. Für einige Zentraleinheiten sind die einzigen verfügbaren Kontrollfluss-Instruktionen bedingte oder vorbehaltlose Zweiginstruktionen (auch genannt Sprünge).

Primitive

Etiketten

Ein Etikett ist ein ausführlicher Name oder Zahl, die einer festen Position innerhalb des Quellcodes zugeteilt ist, und im durch Kontrollfluss-Behauptungen Verweise angebracht werden kann, die anderswohin im Quellcode erscheinen. Anders als Markierung einer Position innerhalb des Quellcodes hat ein Etikett keine Wirkung.

Linienzahlen sind eine Alternative zu einem genannten Etikett (und verwendet auf einigen Sprachen wie Fortran und BASIC), die ganze Zahlen sind, die am Anfang jeder Linie des Textes innerhalb des Quellcodes gelegt sind. Sprachen, die diese häufig verwenden, erlegen die Einschränkung auf, die die Linienzahlen im Wert in jeder nachfolgenden Linie vergrößern müssen, aber nicht verlangen können, dass sie aufeinander folgend sind. Zum Beispiel, im GRUNDLEGENDEN:

10 LASSEN X = 3

20 DRUCK X

</Quelle>

Auf anderen Sprachen wie C und Ada ist ein Etikett ein Bezeichner, gewöhnlich am Anfang einer Linie und sofort gefolgt von einem Doppelpunkt erscheinend. Zum Beispiel, in C:

Erfolg: Printf ("Die Operation war" erfolgreich \n);

</Quelle>

Das ALGOL, das 60 Sprache sowohl ganzen Zahlen als auch Bezeichnern als Etiketten (beide erlaubt hat, die durch Doppelpunkte der folgenden Behauptung beigefügt sind), aber wenige, wenn irgendwelche anderen Varianten des ALGOL ganze Zahlen erlaubt haben.

Goto

Die goto Behauptung (eine Kombination der englischen Wörter und, und hat sich entsprechend ausgesprochen), ist die grundlegendste Form der vorbehaltlosen Übertragung der Kontrolle.

Obwohl das Schlüsselwort entweder in Großbuchstaben oder unterer Umschaltung abhängig von der Sprache sein kann, wird es gewöhnlich als geschrieben:

goto etikettieren

Die Wirkung einer goto Behauptung ist, die folgende Behauptung zu veranlassen, durchgeführt zu werden, um die Behauptung zu sein, die an (oder sofort danach) das angezeigte Etikett erscheint.

Behauptungen von Goto sind schädlich von vielen Computerwissenschaftlern, namentlich Dijkstra betrachtet worden.

Unterprogramme

Die Fachsprache für Unterprogramme ändert sich; sie können als Routinen, Verfahren, Funktionen wechselweise bekannt sein (besonders, wenn sie Ergebnisse zurückgeben) oder Methoden (besonders, wenn sie Klassen oder Typ-Klassen gehören).

In den 1950er Jahren waren Computererinnerungen nach aktuellen Standards sehr klein, so wurden Unterprogramme in erster Linie verwendet, um Programm-Größe zu reduzieren; ein Stück des Codes wurde einmal geschrieben und dann oft von verschiedenen anderen Plätzen im Programm verwendet.

Heutzutage werden Unterprogramme öfter verwendet, um zu helfen, ein Programm zu machen, das, z.B durch das Isolieren eines besonderen Algorithmus oder das Verbergen einer besonderen Datenzugriffsmöglichkeit mehr strukturiert wird.

Wenn viele Programmierer an einem einzelnen Programm arbeiten, sind Unterprogramme eine Art der Modularität, die helfen kann, die Arbeit aufzuteilen.

Minimaler strukturierter Kontrollfluss

Im Mai 1966 haben Böhm und Jacopini einen Artikel in Kommunikationen des ACM veröffentlicht, der gezeigt hat, dass jedes Programm mit gotos in eine goto-freie Form umgestaltet werden konnte, die nur Wahl (WENN DANN SONST) und Schleifen einschließt (WÄHREND Bedingung xxx TUT), vielleicht mit dem kopierten Code und/oder der Hinzufügung von Variablen von Boolean (wahre/falsche Fahnen).

Spätere Autoren haben gezeigt, dass Wahl durch Schleifen (und noch mehr Variablen von Boolean) ersetzt werden kann.

Die Tatsache, dass solcher Minimalismus möglich ist, bedeutet nicht notwendigerweise, dass es wünschenswert ist; schließlich brauchen Computer theoretisch nur

eine Maschineninstruktion (ziehen eine Zahl von einem anderen und Zweig ab, wenn das Ergebnis negativ ist), aber praktische Computer haben Dutzende oder sogar Hunderte von Maschineninstruktionen.

Was Böhms Artikel und Jacopinis gezeigt hat, war, dass alle Programme goto-frei sein konnten.

Andere Forschung hat gezeigt, dass Kontrollstrukturen mit einem Zugang und einem Ausgang viel leichter waren zu verstehen als jede andere Form in erster Linie weil sie überall als eine Behauptung verwendet werden konnten, ohne den Kontrollfluss zu stören. Mit anderen Worten waren sie composable. (Später haben Entwicklungen, wie nichtstrenge Programmiersprachen - und mehr kürzlich, composable Softwaretransaktionen - diesen Gedankenfaden fortgesetzt, Bestandteile von Programmen noch freier composable machend.)

Kontrollstrukturen in der Praxis

Die meisten Programmiersprachen mit Kontrollstrukturen haben ein anfängliches Schlüsselwort, das den Typ der beteiligten Kontrollstruktur anzeigt. Sprachen teilen sich dann betreffs, ob Kontrollstrukturen ein Endschlüsselwort haben.

• Kein Endschlüsselwort: ALGOL 60, C, C ++, Haskell, Java, Pascal, Perl, PHP, PL/I, Pythonschlange, PowerShell. Solche Sprachen brauchen eine Weise, Behauptungen zusammen zu gruppieren:
• ALGOL 60 und Pascal:...
• C, C ++, Java, Perl, PHP und PowerShell: lockige Klammern...
• PL/1:...
• Pythonschlange: Gebrauch-Einrückungsniveau (sieh Abseitsregel)
• Haskell: Entweder Einrückungsniveau oder lockige Klammern können verwendet werden, und sie können frei gemischt werden
• Endschlüsselwort: Ada, ALGOL 68, Modula-2, Fortran 77, Mythryl, Visuell Grundlegend. Die Formen des Endschlüsselwortes ändern sich:
• Ada: Endschlüsselwort ist + Raum + anfängliches Schlüsselwort z.B......
• ALGOL 68, Mythryl: Anfängliches Schlüsselwort hat sich umgekehrt z.B...... geschrieben
• Fortran 77: Endschlüsselwort ist + anfängliches Schlüsselwort z.B......
• Modula-2: dasselbe Endschlüsselwort für alles
• Visuell Grundlegend: Jede Kontrollstruktur hat sein eigenes Schlüsselwort....;...;...;...

Wahl

Wenn dann - (sonst) Behauptungen

Bedingte Ausdrücke und bedingte Konstruktionen sind Eigenschaften einer Programmiersprache, die verschiedene Berechnung oder Handlungen je nachdem durchführen, ob eine Programmierer-angegebene boolean Bedingung zum wahren oder falschen bewertet.

• . Eine auf unstrukturierten Sprachen gefundene Form, eine typische Maschinencodeinstruktion nachahmend, würde zu (GOTO) ein Etikett oder Linienzahl springen, als die Bedingung entsprochen wurde.
• . Anstatt auf einen Sprung eingeschränkt konnte jede einfache Behauptung, oder Block verschachtelt zu werden, DANN Schlüsselschlüsselwort Das eine strukturierte Form folgen.
• . Als oben, aber mit einer zweiten durchzuführenden Handlung, wenn die Bedingung falsch ist. Das ist eine von den meisten Standardformen mit vielen Schwankungen. Einige verlangen ein Terminal, andere tun nicht. C und verwandte Sprachen verlangen kein Endschlüsselwort, oder 'dann', aber verlangen wirklich Parenthesen um die Bedingung.
• Bedingte Behauptungen können sein und werden häufig innerhalb anderer bedingter Behauptungen verschachtelt. Einige Sprachen erlauben und verbunden zu werden in, das Bedürfnis vermeidend, eine Reihe oder andere Endbehauptungen am Ende einer zusammengesetzten Behauptung zu haben.

Weniger allgemeine Schwankungen include: -

• Einige Sprachen, wie Fortran, haben eine "dreiseitige" oder "Arithmetik, wenn", prüfend, ob ein numerischer Wert positiv, negativ ist oder Null.
• Einige Sprachen haben eine funktionelle Form "wenn" Behauptung, zum Beispiel LISPELN
• Einige Sprachen lassen sich einen Maschinenbediener "wenn" Behauptung wie der dreifältige Maschinenbediener von C formen.
• Perl ergänzt einen C-style mit und.
• Plausch-Gebrauch und Nachrichten, um conditionals, aber nicht jede grundsätzliche Sprachkonstruktion durchzuführen.

Fall und Schalter-Behauptungen

Schalter-Behauptungen (auf einigen Sprachen, Fall-Behauptungen oder mehrwegigen Zweigen) vergleichen einen gegebenen Wert mit angegebenen Konstanten und handeln gemäß der ersten Konstante, um zusammenzupassen. Es gibt gewöhnlich eine Bestimmung für eine Verzug-Handlung ('sonst', 'sonst'), um genommen zu werden, wenn kein Match erfolgreich ist. Schalter-Behauptungen können Bearbeiter-Optimierungen wie Nachschlagetabellen erlauben. Auf dynamischen Sprachen dürfen die Fälle nicht auf feste Ausdrücke beschränkt werden, und könnten sich bis zu das Muster-Zusammenbringen, als im Schale-Schrift-Beispiel rechts, wo die Werkzeuge der Verzug-Fall als ein regelmäßiger Ausdruck ausstrecken, der jede Schnur vergleicht. Fall-Logik

kann auch in der funktionellen Form, als in der Behauptung von SQL durchgeführt werden.

Schleifen

Eine Schleife ist eine Folge von Behauptungen, die einmal angegeben wird, aber die mehrere Male in der Folge ausgeführt werden kann.

Dem Code "innerhalb" der Schleife (der Körper der Schleife, die unten als xxx gezeigt ist), wird eine bestimmte Anzahl von Zeiten, oder einmal für jede einer Sammlung von Sachen gefolgt, oder bis etwas Bedingung, oder unbestimmt entsprochen wird.

Auf funktionellen Programmiersprachen, wie Haskell und Schema, können Schleifen durch das Verwenden recursion ausgedrückt werden oder haben Punkt-Wiederholung aber nicht ausführliche sich schlingende Konstruktionen befestigt. Schwanz recursion ist ein spezieller Fall von recursion, der in die Wiederholung leicht umgestaltet werden kann.

Graf-kontrollierte Schleifen

Die meisten Programmiersprachen haben Aufbauten, für eine Schleife eine bestimmte Anzahl von Zeiten zu wiederholen.

Bemerken Sie, dass, wenn N weniger als 1 in diesen Beispielen dann ist, die Sprache angeben kann, dass der Körper völlig ausgelassen wird, oder dass der Körper gerade einmal mit N = 1 durchgeführt wird.

In den meisten Fällen kann das Zählen abwärts statt aufwärts gehen, und Schritt-Größen außer 1 können verwendet werden.

WEIL ich = 1 ZU N weil ich: = 1 zu N beginnen wirklich

xxx xxx

ALS NÄCHSTES ende ich;

TUN SIE mich = 1, N dafür (I=1; ich

für X: = 0.1 Schritt 0.1 zu 1.0 tun

könnte 9- oder 10mal, abhängig von Rundungsfehlern und/oder der Hardware und/oder der Bearbeiter-Version wiederholt werden. Außerdem, wenn die Zunahme X bei der wiederholten Hinzufügung vorkommt, können angesammelte Rundungsfehler bedeuten, dass sich der Wert von X in jeder Wiederholung ganz bedeutsam von der erwarteten Folge 0.1, 0.2, 0.3..., 1.0 unterscheiden kann.

Bedingungskontrollierte Schleifen

Die meisten Programmiersprachen haben Aufbauten, für eine Schleife zu wiederholen, bis sich etwas Bedingung ändert.

Bemerken Sie, dass einige Schwankungen den Test am Anfang der Schleife legen, während andere den Test am Ende der Schleife haben.

Im ehemaligen Fall kann der Körper völlig ausgelassen werden, während im letzten Fall der Körper immer mindestens einmal durchgeführt wird.

TUN SIE, WÄHREND (Test) wiederholt

xxx xxx

SCHLEIFE bis zum Test;

während (Test) {tut

xxx xxx

} während (Test);

Sammlungskontrollierte Schleifen

Mehrere Programmiersprachen (z.B Ada, D, Plausch, Perl, Object Pascal, Java, C#, Mythryl, Visuell Grundlegend, Rubinrot, Pythonschlange, JavaScript, Fortran 95 und später) haben spezielle Konstruktionen, die implizit erlauben, sich durch alle Elemente einer Reihe oder alle Mitglieder eines Satzes oder Sammlung zu schlingen.

someCollection tun: [: eachElement |xxx].

weil der Artikel in der Sammlung wirklich Xxx-Ende beginnt;

foreach (Artikel; myCollection) {xxx }\

foreach someArray {xxx }\

Sammlung

foreach (spannen s in myStringCollection) {xxx }\

$someCollection | ForEach-Gegenstand {$ _ }\

forall (Index = first:last:step...)

Allgemeine Wiederholung

Allgemeine Wiederholungskonstruktionen wie C für die Behauptung und Allgemeines Lispeln formen sich wirklich kann verwendet werden, um einige der obengenannten Sorten von Schleifen, sowie anderen — wie das Schlingen über mehrere Sammlungen in der Parallele auszudrücken. Wo eine spezifischere sich schlingende Konstruktion verwendet werden kann, wird sie gewöhnlich über die allgemeine Wiederholungskonstruktion bevorzugt, da sie häufig den Zweck des Ausdrucks klarer macht.

Unendliche Schleifen

Unendliche Schleifen werden verwendet, um ein Programm-Segment Schleifen für immer zu sichern, oder bis eine außergewöhnliche Bedingung wie ein Fehler entsteht. Zum Beispiel sollte ein Ereignis-gesteuertes Programm (wie ein Server) für immer behandelnde Ereignisse schlingen, wie sie vorkommen, nur anhaltend, wenn der Prozess von einem Maschinenbediener begrenzt wird.

Häufig wird eine unendliche Schleife durch einen Programmierfehler in einer Bedingungskontrollierten Schleife unabsichtlich geschaffen, worin die Schleife-Bedingung Variablen verwendet, die sich nie innerhalb der Schleife ändern.

Verlängerung mit der folgenden Wiederholung

Manchmal innerhalb des Körpers einer Schleife gibt es einen Wunsch, den Rest des Schleife-Körpers auszulassen und mit der folgenden Wiederholung der Schleife weiterzugehen. Einige Sprachen stellen eine Behauptung solcher als (die meisten Sprachen) zur Verfügung, oder (Perl und Ruby), der das tun wird. Die Wirkung ist, den innersten Schleife-Körper vorzeitig zu begrenzen und dann als normal mit der folgenden Wiederholung die Tätigkeit wieder aufzunehmen. Wenn die Wiederholung die letzte in der Schleife ist, ist die Wirkung, die komplette Schleife früh zu begrenzen.

Tun Sie aktuelle Wiederholung nochmals

Einige Sprachen, wie Perl und Ruby, haben eine Behauptung, die die aktuelle Wiederholung vom Anfang wiederanfängt.

Fangen Sie Schleife wiederan

Rubin hat eine Behauptung, die die komplette Schleife von der anfänglichen Wiederholung wiederanfängt.

Früher Ausgang von Schleifen

Als

man eine Zählungskontrollierte Schleife verwendet hat, um einen Tisch zu durchsuchen, könnte es wünschenswert sein aufzuhören zu suchen, sobald der erforderliche Artikel gefunden wird. Einige Programmiersprachen stellen eine Behauptung solcher als (die meisten Sprachen), oder (Perl) zur Verfügung, dessen Wirkung ist, die aktuelle Schleife sofort und Übertragungskontrolle zur Behauptung sofort im Anschluss an diese Schleife zu begrenzen. Man kann auch aus einem Unterprogramm, das die geschlungenen Behauptungen durchführt, sowohl aus der verschachtelten Schleife als auch aus dem Unterprogramm brechend. Dinge können ein bisschen unordentlich werden, wenn sie einen mehrdimensionalen Tisch mit verschachtelten Schleifen suchen (sieh #Proposed Kontrollstrukturen unten).

Das folgende Beispiel wird in Ada getan, die sowohl frühen Ausgang von Schleifen als auch Schleifen mit dem Test in der Mitte unterstützt. Beide Eigenschaften sind sehr ähnlich und sich vergleichend beide Codeschnipsel werden den Unterschied zeigen: Früh muss Ausgang mit verbunden werden, wenn Behauptung, während eine Bedingung in der Mitte selbst enthaltene Konstruktion ist.

mit Ada. Text IO;

mit Ada. Text der ganzen Zahl IO;

Verfahren Print_Squares ist

X: Ganze Zahl;

beginnen Sie

Read_Data: Schleife

Ada. Text der ganzen Zahl IO.Get (X);

herrschen Sie über Read_Data wenn X = 0;

Ada. Text IO.Put (X * X);

Ada. Text IO.New_Line;

Endschleife Read_Data;

Ende Print_Squares;

</Quelle>

Pythonschlange unterstützt bedingte Ausführung des Codes je nachdem, ob über eine Schleife früh (mit einer Behauptung) oder nicht durch das Verwenden einer Sonst-Klausel mit der Schleife geherrscht wurde. Zum Beispiel,

für n in set_of_numbers:

wenn isprime (n):

Druck "Satz enthält eine Primzahl"

Brechung

sonst:

Druck "Satz hat keine Primzahlen" enthalten

</Quelle>

Bemerken Sie, dass die Klausel im obengenannten Beispiel der Behauptung und nicht der inneren Behauptung beigefügt wird. Sowohl Pythonschlange als auch Schleifen unterstützt solch einen sonst Klausel, die nur durchgeführt wird, wenn der frühe Ausgang der Schleife nicht vorgekommen ist.

Schleife-Varianten und invariants

Schleife-Varianten und Schleife invariants werden verwendet, um Genauigkeit von Schleifen auszudrücken.

In praktischen Begriffen ist eine Schleife-Variante ein Ausdruck der ganzen Zahl, der einen anfänglichen nichtnegativen Wert hat. Der Wert der Variante muss während jeder Schleife-Wiederholung abnehmen, aber muss negativ während der richtigen Ausführung der Schleife nie werden. Schleife-Varianten werden verwendet, um zu versichern, dass Schleifen enden werden.

Eine Schleife invariant ist eine Behauptung, die vor der ersten Schleife-Wiederholung wahr sein und wahr nach jeder Wiederholung bleiben muss. Das deutet an, dass, wenn eine Schleife richtig, sowohl die Ausgangsbedingung als auch die Schleife endet, invariant zufrieden sind. Schleife invariants wird verwendet, um spezifische Eigenschaften einer Schleife während aufeinander folgender Wiederholungen zu kontrollieren.

Einige Programmiersprachen, wie Eiffel enthalten heimische Unterstützung für Schleife-Varianten und invariants. In anderen Fällen ist Unterstützung eine Erweiterung wie Java, die Spezifizierung der Sprache für Schleife-Behauptungen in Java Modellierend.

Schleife-Systemquerverweis-Tisch

1. zählt als eine unendliche Schleife für diesen Zweck nicht, weil es nicht eine hingebungsvolle Sprachstruktur ist.

1. Die Schleife von C ist eine allgemeine Schleife-Konstruktion, nicht spezifisch eine zählende, obwohl sie häufig dafür verwendet wird.

1. Tiefe Brechungen können in C, C ++ und C# durch den Gebrauch von Etiketten und gotos vollbracht werden.

1. Die Wiederholung über Gegenstände wurde in PHP 5 hinzugefügt.

1. Eine Zählen-Schleife kann durch das Wiederholen über eine erhöhende Liste oder Generator, zum Beispiel, der Pythonschlange vorgetäuscht werden.

1. Tiefe Brechungen können durch den Gebrauch des Ausnahme-Berührens vollbracht werden.

1. Es gibt keine spezielle Konstruktion, da die Funktion dafür verwendet werden kann.

1. Es gibt keine spezielle Konstruktion, aber Benutzer können allgemeine Schleife-Funktionen definieren.

1. Der C ++ 11 Standard hat das Reihe-basierte dafür eingeführt. Im STL gibt es eine Schablone-Funktion, die auf STL Behältern wiederholen und eine unäre Funktion nach jedem Element nennen kann. Die Funktionalität kann auch als Makro-auf diesen Behältern gebaut werden.

1. Zählen Sie das kontrollierte Schlingen wird durch die Wiederholung über einen Zwischenraum der ganzen Zahl bewirkt; früher Ausgang durch das Umfassen einer zusätzlichen Bedingung für den Ausgang.

1. Eiffel unterstützt ein vorbestelltes Wort, jedoch wird er im Ausnahme-Berühren, nicht der Schleife-Kontrolle verwendet.

1. Verlangt Java Modeling Language (JML) Verhaltensschnittstelle-Spezifizierungssprache.

1. Verlangt, dass Schleife-Varianten ganze Zahlen sind; transfinite Varianten werden nicht unterstützt.

http://archive.eiffel.com/doc/faq/variant.html

Strukturierter nichtlokaler Kontrollfluss

Viele Programmiersprachen, besonders diejenigen, die dynamischere Stile der Programmierung, Angebot-Konstruktionen für den nichtlokalen Kontrollfluss bevorzugen. Diese veranlassen den Fluss der Ausführung, aus einem gegebenen Zusammenhang und Zusammenfassung an einem offen vorerklärten Punkt zu springen. Bedingungen, Ausnahmen und Verlängerungen sind drei allgemeine Sorten von nichtlokalen Kontrollkonstruktionen.

Bedingungen

PL/I hat ungefähr 22 Standardbedingungen (z.B ZERODIVIDE SUBSCRIPTRANGE ENDFILE), der ERHOBEN werden kann, und der abgefangen werden kann durch: AUF der Bedingungshandlung; Programmierer können auch definieren und ihre eigenen genannten Bedingungen verwenden.

Wie das unstrukturierte, wenn nur eine Behauptung so in vielen Fällen angegeben werden kann, ist ein GOTO erforderlich, um zu entscheiden, wo der Fluss der Kontrolle die Tätigkeit wieder aufnehmen sollte.

Leider hatten einige Durchführungen einen wesentlichen oben in beider Zeit und Raum (besonders SUBSCRIPTRANGE), so viele Programmierer haben versucht zu vermeiden, Bedingungen zu verwenden.

Allgemeine Syntax-Beispiele:

AUF der Bedingung etikettieren GOTO

Ausnahmen

Neuere Sprachen haben eine strukturierte Konstruktion für das Ausnahme-Berühren, das sich auf den Gebrauch nicht verlässt:

versuchen Sie {\

xxx1//Irgendwo in hier

xxx2//Gebrauch: Werfen someValue;

xxx3

} Fang (someClass& someId) {//fangen Wert von someClass

actionForSomeClass

} Fang (someType& anotherId) {//fangen Wert von someType

actionForSomeType

} Fang (...) {//fangen irgendetwas nicht bereits gefangener

actionForAnythingElse

}\</Quelle>

Jede Zahl und Vielfalt von Klauseln können oben verwendet werden. In D, Java, C#, und Pythonschlange kann eine Klausel zur Konstruktion hinzugefügt werden. Egal wie Kontrolle abreist, wie man versichert, führt der Code innerhalb der Klausel durch. Das ist nützlich, wenn es Code schreibt, der eine teure Quelle (wie eine geöffnete Datei oder eine Datenbankverbindung), wenn beendet, aufgeben muss in einer Prozession gehend:

FileStream stm = ungültig;//C# Beispiel

versuchen Sie {\

stm = neuer FileStream ("logfile.txt", FileMode. Schaffen Sie);

geben Sie ProcessStuff (stm) zurück;//kann eine Ausnahme werfen

} schließlich {\

wenn (stm! = ungültig)

stm. Nahe ;

}\</Quelle>

Da dieses Muster ziemlich üblich ist, C# hat eine spezielle Syntax:

mit (FileStream stm = neuer FileStream ("logfile.txt", FileMode. Schaffen Sie)) {\

geben Sie ProcessStuff (stm) zurück;//kann eine Ausnahme werfen}\</Quelle>

Nach dem Verlassen - Block versichert der Bearbeiter, dass der Gegenstand veröffentlicht wird. Die Behauptung der Pythonschlange und das Block-Argument von Ruby dafür werden zur ähnlichen Wirkung verwendet.

Alle diese Sprachen definieren Standardausnahmen und die Verhältnisse, unter denen sie geworfen werden.

Benutzer können werfen Ausnahmen ihres eigenen (tatsächlich C ++ erlaubt Benutzern, fast jeden Typ zu werfen und zu fangen).

Wenn es kein Zusammenbringen einer Einzelheit gibt, sickert Kontrolle zurück durch Unterprogramm-Anrufe durch und/oder hat Blöcke verschachtelt, bis ein Zusammenbringen gefunden wird, oder bis das Ende des Hauptprogramms erreicht wird, an dem Punkt das Programm mit einer passenden Fehlermeldung gewaltsam angehalten wird.

AppleScript scripting Programmiersprache stellt mehrere Information einem "" Block zur Verfügung:

versuchen Sie

Satz myNumber zu myNumber / 0

auf dem Fehler e Nummer n von f bis t teilweises Ergebnis pr

wenn (e = "Kann sich durch die Null" nicht teilen), dann Dialog zeigen, "Müssen Sie nicht das" tun

enden Sie versuchen

</Quelle>

Verlängerungen

Nichtlokaler Kontrollfluss-Querverweis

Vorgeschlagene Kontrollstrukturen

In einem Veralberungsartikel Datamation 1973 hat R. Lawrence Clark vorgeschlagen, dass die GOTO Behauptung durch die COMEFROM Behauptung ersetzt werden konnte, und einige unterhaltende Beispiele zur Verfügung stellt.

Das wurde wirklich in INTERCAL, einer absichtlich esoterischen Programmiersprache-Sprache durchgeführt.

In seinem 1974-Artikel "Structured Programming with go to Statements" hat Donald Knuth zwei Situationen identifiziert, die nicht bedeckt wurden

durch die Kontrollstrukturen, die oben verzeichnet sind, und hat Beispiele von Kontrollstrukturen angeführt, die diese Situationen behandeln konnten. Trotz ihres Dienstprogrammes haben diese Aufbauten ihren Weg in Hauptströmungsprogrammiersprachen noch nicht gefunden.

Schleife mit dem Test in der Mitte

Der folgende wurde von Dahl 1972 vorgeschlagen:

Schleife-Schleife

xxx1 hat (Rotforelle) gelesen;

während Test; während nicht atEndOfFile;

xxx2 schreiben (Rotforelle);

wiederholen Sie sich; wiederholen Sie sich;

Wenn xxx1 weggelassen wird, bekommen wir eine Schleife mit dem Test oben.

Wenn xxx2 weggelassen wird, bekommen wir eine Schleife mit dem Test am Boden.

Wenn, während weggelassen wird, wir eine unendliche Schleife bekommen.

Folglich kann dieser einzelne Aufbau mehrere Aufbauten auf den meisten Programmiersprachen ersetzen.

Eine mögliche Variante soll mehr als einen während Test erlauben; innerhalb der Schleife, aber des Gebrauches von exitwhen (sieh folgende Abteilung), scheint, diesen Fall besser zu bedecken.

Sprachen, die an dieser Konstruktion allgemein Mangel haben, eifern damit mit einer gleichwertigen unendlichen Schleife mit dem Brechungsidiom wett:

während (wahr), {\

xxx1

wenn (nicht prüfen)

,

Brechung

xxx2

}\

In Ada, die obengenannte Schleife-Konstruktion (Schleife während Wiederholung) kann mit einer unendlichen Standardschleife vertreten werden (Schleife - Endschleife), der einen Ausgang wenn Klausel in der Mitte hat (um mit der exitwhen Behauptung in der folgenden Abteilung nicht verwirrt zu sein).

mit Ada. Text_IO;

mit Ada. Integer_Text_IO;

Verfahren Print_Squares ist X: Ganze Zahl;beginnen Sie Read_Data: Schleife

Ada. Integer_Text_IO.Get (X);

herrschen Sie über Read_Data wenn X = 0; Ada. Text IO.Put (X * X); Ada. Text IO.New_Line; Endschleife Read_Data;Ende Print_Squares;</Quelle>

Das Namengeben einer Schleife (wie Read_Data in diesem Beispiel) ist fakultativ, aber erlaubt, die Außenschleife von mehreren verschachtelten Schleifen zu verlassen.

Vielfacher früher Ausgang/Ausgang von verschachtelten Schleifen

Das wurde von Zahn 1974 vorgeschlagen. Eine modifizierte Version wird hier präsentiert.

exitwhen EventA oder EventB oder EventC;

xxx

Ausgänge

EventA: actionA

EventB: actionB

EventC: actionC

endexit;

exitwhen wird verwendet, um die Ereignisse anzugeben, die innerhalb von xxx, vorkommen können

ihr Ereignis wird durch das Verwenden des Namens des Ereignisses als eine Behauptung angezeigt.

Wenn ein Ereignis wirklich vorkommt, wird die relevante Handlung ausgeführt, und dann kontrollieren Sie Pässe gerade danach endexit.

Dieser Aufbau stellt eine sehr klare Trennung zwischen der Bestimmung zur Verfügung, dass etwas Situation, und die für diese Situation zu nehmende Handlung gilt.

exitwhen ist dem Ausnahme-Berühren begrifflich ähnlich, und Ausnahmen oder ähnliche Konstruktionen werden für diesen Zweck auf vielen Sprachen verwendet.

Das folgende einfache Beispiel schließt Suche eines zweidimensionalen Tisches für einen besonderen Artikel ein.

exitwhen gefunden oder Vermisste;

weil ich: = 1 zu N tun

für J: = 1 zur M tun

wenn Tisch [ich, J] = dann gefunden ins Visier nehme;

Vermisste;

Ausgänge

gefunden: Druck ("Artikel ist im Tisch");

Vermisste: Druck ("Artikel ist nicht im Tisch");

endexit;

Siehe auch

• Zweig (Informatik)
• Kontrollflussschema
• Kontrollfluss-Graph
• Steuertabelle
• Koroutine
• Kompliziertheit von Cyclomatic
• Flussschema
• GOTO
• Jeroo, hilft, Kontrollstrukturen zu erfahren
• Hauptschleife
• Recursion
• Spaghetti codieren
• Strukturierte Programmierung
• Unterprogramm
• Schalter-Behauptung, verändert Kontrollfluss bedingt
• Hoare, C. A. R. "Teilung: Algorithmus 63," "Schnellsortierung: Algorithmus 64," und "Findet: Algorithmus 65." Comm. ACM 4, 321-322, 1961.

Außenverbindungen

• Gehen Sie zur Behauptung überlegter schädlicher
• Ein Sprachbeitrag von GOTO-weniger Programmierung