Поток управления - Control flow

В Информатика, поток управления (или же поток управления) - это порядок, в котором заявления, инструкции или же вызовы функций из императив программа находятся казнен или оценивается. Акцент на явном потоке управления отличает императивное программирование язык из декларативное программирование язык.

В рамках императива язык программирования, а оператор потока управления это утверждение, в результате которого делается выбор, по какому из двух или более путей следовать. За нестрогий функциональные языки, функции и языковые конструкции существуют для достижения того же результата, но их обычно не называют операторами потока управления.

Набор утверждений, в свою очередь, обычно структурирован как блокировать, который помимо группировки также определяет лексическая область.

Прерывания и сигналы представляют собой низкоуровневые механизмы, которые могут изменять поток управления аналогично подпрограмме, но обычно возникают как реакция на некоторый внешний стимул или событие (которое может произойти асинхронно ), а не выполнение в соответствии оператор потока управления.

На уровне машинный язык или же язык ассемблера, инструкции потока управления обычно работают, изменяя счетчик команд. Для некоторых центральные процессоры (CPU), единственные доступные инструкции потока управления являются условными или безусловными. ответвляться инструкции, также называемые прыжками.

Категории

А блок-схема показывая поток управления.

Типы операторов потока управления, поддерживаемые разными языками, различаются, но их можно разделить на категории по их эффекту:

• Продолжение в другом заявлении (безусловное ответвляться или прыгать)
• Выполнение набора операторов только при соблюдении некоторого условия (выбор - т.е. условная ветвь )
• Выполнение набора операторов ноль или более раз, пока не будет выполнено какое-либо условие (т. Е. Цикл - то же, что и условная ветвь )
• Выполнение набора удаленных операторов, после которого поток управления обычно возвращает (подпрограммы, сопрограммы, и продолжения )
• Остановка программы, предотвращение дальнейшего выполнения (безусловная остановка)

Примитивы

Этикетки

А метка явное имя или номер, присвоенный фиксированной позиции в пределах исходный код, и на которые могут ссылаться операторы потока управления, появляющиеся в другом месте исходного кода. Метка отмечает позицию в исходном коде и не имеет никакого другого эффекта.

Номера строк являются альтернативой именованной метке, используемой в некоторых языках (например, БАЗОВЫЙ ). Они есть целые числа помещается в начало каждой строки текста в исходном коде. Языки, в которых они используются, часто накладывают ограничение, согласно которому номера строк должны увеличиваться в значении в каждой следующей строке, но могут не требовать, чтобы они были последовательными. Например, в BASIC:

10ПОЗВОЛЯТЬИкс=320РАСПЕЧАТАТЬИкс

На других языках, таких как C и Ада, метка - это идентификатор, обычно появляется в начале строки и сразу после него ставится двоеточие. Например, в C:

Успех: printf(«Операция прошла успешно. п");

Язык АЛГОЛ 60 разрешены как целые числа, так и идентификаторы в качестве меток (оба связаны двоеточиями со следующим утверждением), но мало, если вообще АЛГОЛ варианты разрешены целыми числами. Рано Фортран компиляторы разрешили использовать только целые числа в качестве меток. Начиная с Fortran-90, также разрешены буквенно-цифровые метки.

Идти к

В идти к заявление (сочетание английских слов идти и к, и произносится соответственно) является основной формой безусловной передачи управления.

Хотя ключевое слово может быть в верхнем или нижнем регистре в зависимости от языка, обычно это пишется как:

   идти к метка

Эффект оператора goto заключается в том, что следующий оператор, который будет выполнен, будет оператором, появляющимся на (или сразу после) указанной метке.

Заявления Goto были считается вредным многими компьютерными учеными, особенно Dijkstra.

Подпрограммы

Терминология для подпрограммы варьируется; в качестве альтернативы они могут называться подпрограммами, процедурами, функциями (особенно если они возвращают результаты) или методами (особенно если они принадлежат классы или же типовые классы ).

В 1950-х годах компьютерная память была очень маленькой по нынешним стандартам, поэтому в основном использовались подпрограммы.^{[нужна цитата ]} для уменьшения размера программы. Кусок кода был написан один раз, а затем многократно использовался в различных других местах программы.

Сегодня подпрограммы чаще используются, чтобы помочь сделать программу более структурированной, например, путем изоляции некоторого алгоритма или сокрытия некоторого метода доступа к данным. Если над одной программой работают многие программисты, подпрограммы - это один из видов модульность это может помочь разделить работу.

Последовательность

В структурном программировании упорядоченная последовательность последовательных команд считается одной из базовых структур управления, которая используется в качестве строительного блока для программ наряду с итерацией, рекурсией и выбором.

Минимальный структурированный поток управления

В мае 1966 года Бём и Якопини опубликовали статью^[1] в Коммуникации ACM который показал, что любая программа с идти кs можно преобразовать в форму без перехода, включающую только выбор (IF THEN ELSE) и циклы (WHILE, условие DO xxx), возможно, с дублированным кодом и / или добавлением логических переменных (флаги true / false). Позднее авторы показали, что выбор можно заменить циклами (и тем более логическими переменными).

То, что такой минимализм возможен, не означает, что он обязательно желателен; в конце концов, компьютерам теоретически нужно только одна машинная инструкция (вычтите одно число из другого и выполните переход, если результат отрицательный), но на практике компьютеры имеют десятки или даже сотни машинных инструкций.

Статья Бема и Якопини показала, что все программы могут быть свободными от goto. Другое исследование показало, что управляющие структуры с одним входом и одним выходом намного легче понять, чем любую другую форму.^{[нужна цитата ]} главным образом потому, что их можно было использовать где угодно в качестве оператора, не нарушая потока управления. Другими словами, они были составной. (Более поздние разработки, такие как нестрогие языки программирования - и в последнее время составные программные транзакции - продолжили эту стратегию, сделав компоненты программ еще более свободно компонуемыми.)

Некоторые ученые придерживались пуристского подхода к результату Бема-Якопини и утверждали, что даже такие инструкции, как перемена и возвращаться от середины петель - плохая практика, поскольку они не нужны в доказательстве Бема-Якопини, и поэтому они выступали за то, чтобы все петли имели единственную точку выхода. Этот пуристический подход воплощен в языке Паскаль (разработан в 1968–1969 гг.), который до середины 1990-х был предпочтительным инструментом для обучения вводному программированию в академических кругах.^[2] Прямое применение теоремы Бёма-Якопини может привести к введению дополнительных локальных переменных в структурированную карту, а также может привести к некоторым дублирование кода.^[3] На Паскаль влияют обе эти проблемы, и, согласно эмпирическим исследованиям, процитированным Эрик С. Робертс студенты-программисты испытывали трудности с формулированием правильных решений на Паскале для нескольких простых задач, в том числе для написания функции для поиска элемента в массиве. Исследование 1980 года Генри Шапиро, цитируемое Робертсом, показало, что при использовании только управляющих структур, предоставленных Паскалем, правильное решение было дано только 20% испытуемых, в то время как ни один из испытуемых не написал неправильный код для этой проблемы, если бы разрешили написать ответ из середина петли.^[2]

Управляющие структуры на практике

В большинстве языков программирования с управляющими структурами есть начальное ключевое слово, которое указывает тип задействованной управляющей структуры.^{[требуется разъяснение ]} Затем языки разделяются относительно того, есть ли у управляющих структур последнее ключевое слово.

• Без окончательного ключевого слова: АЛГОЛ 60, C, C ++, Haskell, Ява, Паскаль, Perl, PHP, PL / I, Python, PowerShell. Таким языкам нужен способ группировки операторов вместе:
  • АЛГОЛ 60 и Паскаль: начинать ... конец
  • C, C ++, Java, Perl, PHP и PowerShell: фигурные скобки { ... }
  • PL / I: ДЕЛАТЬ ... КОНЕЦ
  • Python: использует отступ уровень (см. Off-side правило )
  • Haskell: либо отступ можно использовать ровные или фигурные скобки, и их можно свободно смешивать
  • Lua: использует делать ... конец
• Последнее ключевое слово: Ада, АЛГОЛ 68, Модула-2, Фортран 77, Мифрил, Visual Basic. Формы последнего ключевого слова различаются:
  • Ада: последнее ключевое слово конец + Космос + начальное ключевое слово, например, если ... конец, если, петля ... конец цикла
  • АЛГОЛ 68, Мифрил: начальное ключевое слово написано в обратном порядке, например, если ... фи, дело ... esac
  • Fortran 77: последнее ключевое слово - КОНЕЦ + начальное ключевое слово, например, ЕСЛИ ... ENDIF, ДЕЛАТЬ ... ENDDO
  • Модула-2: то же самое последнее ключевое слово КОНЕЦ За все
  • Visual Basic: каждая структура управления имеет собственное ключевое слово. Если ... Конец, если; За ... Следующий; Делать ... Петля; Пока ... Wend

Выбор

Если-то- (еще) утверждения

Условные выражения и условные конструкции являются особенностями язык программирования которые выполняют различные вычисления или действия в зависимости от того, указал ли программист логический условие оценивается как истина или ложь.

• ЕСЛИ..ПЕРЕЙТИ. Форма, найденная в неструктурированных языках, имитирующая типичную инструкцию машинного кода, перескакивает на (GOTO) метку или номер строки при выполнении условия.
• ЕСЛИ ... ТО ... (ENDIF). Вместо того, чтобы ограничиваться переходом, любой простой оператор или вложенный блок может следовать за ключевым словом THEN. Это структурированная форма.
• ЕСЛИ ... ТО ... ЭЛЬКО .. (ENDIF). То же, что и выше, но со вторым действием, которое должно быть выполнено, если условие ложно. Это одна из самых распространенных форм с множеством вариаций. Некоторым требуется терминал ENDIF, другие нет. C и родственные языки не требуют ключевого слова терминала или 'then', но требуют скобок вокруг условия.
• Условные операторы могут быть и часто вложены в другие условные операторы. Некоторые языки позволяют ЕЩЕ и ЕСЛИ быть объединенным в ELSEIF, избегая необходимости иметь серию ENDIF или другие заключительные утверждения в конце составного утверждения.

если а > 0 тогда  Writeln("да")еще  Writeln("нет");

если а > 0 тогда      Put_Line("да");еще      Put_Line("нет");конец если;

если (а > 0) {     printf("да");}еще {    printf("нет");}

если [ $ а -gt 0 ]; тогда      эхо "да"еще      эхо "нет"фи

если а > 0:     Распечатать("да")еще:    Распечатать("нет")

(принц  (если (плюс а)      "да"      "нет"))

Менее распространенные варианты включают:

• Некоторые языки, например Фортран, есть трехсторонний или же арифметика, если, проверка того, является ли числовое значение положительным, отрицательным или нулевым.
• Некоторые языки имеют функциональный форма если заявление, например Лиспа cond.
• Некоторые языки имеют оператор форма если заявление, такое как C тернарный оператор.
• Perl дополняет C-стиль если с когда и пока не.
• Болтовня использует если правда и ifFalse сообщения для реализации условных выражений, а не какие-либо фундаментальные языковые конструкции.

Операторы case и switch

Операторы переключения (или же заявления случая, или же разветвления) сравнить заданное значение с заданными константами и предпринять действия в соответствии с первой совпадающей константой. Обычно существует положение о том, что действие по умолчанию («иначе», «иначе») должно выполняться, если совпадение не было успешным. Операторы switch могут допускать оптимизацию компилятора, например таблицы поиска. В динамические языки, случаи не могут быть ограничены константными выражениями и могут распространяться на сопоставление с образцом, как в сценарий оболочки пример справа, где *) реализует случай по умолчанию как шарик соответствие любой строке. Кейс-логика также может быть реализована в функциональной форме, как в SQL с расшифровать утверждение.

дело someChar из  'а': actionOnA;  'Икс': actionOnX;  'y','z':actionOnYandZ;  еще actionOnNoMatch;конец;

дело someChar является  когда 'а' => actionOnA;  когда 'Икс' => actionOnX;  когда 'у' | 'z' => actionOnYandZ;  когда другие => actionOnNoMatch;конец;

выключатель (someChar) {  дело 'а': actionOnA; перемена;  дело 'Икс': actionOnX; перемена;  дело 'y':  дело 'z': actionOnYandZ; перемена;  дефолт: actionOnNoMatch;}

дело $ someChar в)    actionOnA ;;   Икс)    actionOnX ;;   [yz]) actionOnYandZ ;;   *)    actionOnNoMatch ;;esac

(дело какой-то  ((#  а)     действие на)  ((#Икс)     действие-на-х)  ((#  y #  z) действие на y и z)  (еще      действие без совпадения))

Петли

Цикл - это последовательность операторов, которая указывается один раз, но может выполняться несколько раз подряд. Код «внутри» цикла ( тело цикла, показанного ниже как ххх) соблюдается указанное количество раз или один раз для каждой коллекции элементов, или пока не будет выполнено какое-либо условие, или бесконечно.

В функциональное программирование языки, такие как Haskell и Схема, циклы могут быть выражены с помощью рекурсия или же итерация с фиксированной точкой а не явные конструкции цикла. Хвостовая рекурсия это частный случай рекурсии, который легко трансформируется в итерацию.

Петли с контролем счета

В большинстве языков программирования есть конструкции для повторения цикла определенное количество раз. В большинстве случаев счет может идти вниз, а не вверх, и можно использовать размеры шага, отличные от 1.

   ДЛЯ I = 1 К N | за I: = 1 к N делать начинать       ххх | xxx NEXT I | конец; ------------------------------------------------- ----------- DO I = 1, N | за (I = 1; I <= N; ++ I) {xxx | xxx END DO | }

В этих примерах, если N <1, тело цикла может выполняться один раз (при I, имеющем значение 1) или не выполняться вообще, в зависимости от языка программирования.

Во многих языках программирования только целые числа могут надежно использоваться в цикле, управляемом счетчиком. Числа с плавающей запятой представлены неточно из-за аппаратных ограничений, поэтому цикл, например

   за X: = 0,1 шаг 0.1 к 1.0 делать

может повторяться 9 или 10 раз, в зависимости от ошибок округления и / или оборудования и / или версии компилятора. Кроме того, если приращение X происходит путем повторного сложения, накопленные ошибки округления могут означать, что значение X в каждой итерации может значительно отличаться от ожидаемой последовательности 0,1, 0,2, 0,3, ..., 1,0.

Циклы с контролем состояния

В большинстве языков программирования есть конструкции для повторения цикла до тех пор, пока какое-либо условие не изменится. Некоторые варианты проверяют условие в начале цикла; другие тестируют его в конце. Если тест в начале, тело можно полностью пропустить; если он находится в конце, тело всегда выполняется хотя бы один раз.

   ДЕЛАЙТЕ ПОКА (тест) | повторение        ххх | xxx LOOP | до того как тест;---------------------------------------------- пока (тест) {| делать       ххх | xxx} | пока (тест);

А контрольный перерыв - это метод обнаружения изменения значения, используемый в обычных циклах для запуска обработки для групп значений. Значения отслеживаются в цикле, и изменение перенаправляет поток программы на обработку связанного с ними группового события.

   DO UNTIL (конец файла) IF new-zipcode <> current-zipcode display_tally (current-zipcode, zipcount) current-zipcode = new-zipcode zipcount = 0 ENDIF zipcount ++ LOOP

Петли, контролируемые сбором

Несколько языков программирования (например, Ада, D, C ++ 11, Болтовня, PHP, Perl, Object Pascal, Ява, C #, MATLAB, Visual Basic, Рубин, Python, JavaScript, Фортран 95 и более поздние версии) имеют специальные конструкции, которые позволяют неявный цикл по всем элементам массива или всем членам набора или коллекции.

   someCollection делать: [: eachElement | xxx].

   за Элемент в Коллекция делать начинать ххх конец;   для каждого (элемент; myCollection) {xxx} для каждого someArray {xxx} для каждого ($ someArray as $ k => $ v) {xxx} Коллекция  coll; за (Строка s: coll) {} для каждого (нить s в myStringCollection) {xxx} someCollection | ForEach-Object {$ _}

   для всех (индекс = первый: последний: шаг ...)

Scala имеет выражения, которые обобщают циклы, управляемые коллекцией, а также поддерживают другие применения, такие как асинхронное программирование. Haskell имеет do-выражения и понимания, которые вместе предоставляют функции, аналогичные функциям for в Scala.

Общая итерация

Общие конструкции итераций, такие как C за заявление и Common Lisp с делать form может использоваться для выражения любого из вышеупомянутых видов циклов, а также других, таких как параллельный цикл по некоторому количеству коллекций. Там, где может использоваться более конкретная конструкция цикла, она обычно предпочтительнее общей конструкции итерации, поскольку она часто делает цель выражения более ясной.

Бесконечные петли

Бесконечные петли используются, чтобы гарантировать, что сегмент программы будет циклически повторяться навсегда или до тех пор, пока не возникнет исключительное условие, такое как ошибка. Например, программа, управляемая событиями (такая как сервер ) должен зацикливаться вечно, обрабатывая события по мере их возникновения, останавливаясь только тогда, когда процесс завершается оператором.

Бесконечные циклы могут быть реализованы с использованием других конструкций потока управления. Чаще всего в неструктурированном программировании это прыжок назад (goto), тогда как в структурированном программировании это неопределенный цикл (цикл while), для которого задано никогда не заканчиваться, либо путем пропуска условия, либо явным установлением для него значения true, как пока (правда) .... В некоторых языках есть специальные конструкции для бесконечных циклов, обычно путем исключения условия из неопределенного цикла. Примеры включают Ada (цикл ... конец цикла),^[4] Фортран (ДЕЛАТЬ ... КОНЕЦ ДЕЛАТЬ), Идти (за { ... }) и Руби (цикл делать ... конец).

Часто бесконечный цикл непреднамеренно создается из-за ошибки программирования в цикле, управляемом условием, при этом условие цикла использует переменные, которые никогда не изменяются в цикле.

Продолжение со следующей итерацией

Иногда внутри тела цикла возникает желание пропустить оставшуюся часть тела цикла и продолжить следующую итерацию цикла. Некоторые языки содержат такие утверждения, как Продолжить (большинство языков), пропускать,^[5] или же следующий (Perl и Ruby), которые это сделают. Результатом является преждевременное завершение самого внутреннего тела цикла, а затем возобновление в обычном режиме со следующей итерацией. Если итерация является последней в цикле, результатом будет досрочное завершение всего цикла.

Повторить текущую итерацию

Некоторые языки, например Perl^[6] и Руби,^[7] есть повторить оператор, который перезапускает текущую итерацию с самого начала.

Цикл перезапуска

Руби имеет повторить попытку оператор, который перезапускает весь цикл с начальной итерации.^[8]

Ранний выход из петель

При использовании цикла с управлением счетчиком для поиска в таблице может быть желательно остановить поиск, как только будет найден требуемый элемент. Некоторые языки программирования содержат такие инструкции, как перемена (большинство языков), Выход (Visual Basic) или последний (Perl), результатом чего является немедленное завершение текущего цикла и передача управления оператору сразу после этого цикла. Другой термин для циклов раннего выхода: полуторная.

Следующий пример выполнен в Ада который поддерживает оба ранний выход из петель и петли с тестом посередине. Обе функции очень похожи, и сравнение обоих фрагментов кода покажет разницу: ранний выход должен сочетаться с если заявление в то время как состояние в середине это автономная конструкция.

с Ada.Text IO;с Ada.Integer Текст IO;процедура Print_Squares является     Икс : Целое число;начинать    Read_Data : петля        Ада.Целое число Текст IO.Получать(Икс);    выход Read_Data когда Икс = 0;        Ада.Текст IO.Положить (Икс * Икс);        Ада.Текст IO.Новая линия;    конец петля Read_Data;конец Print_Squares;

Python поддерживает условное выполнение кода в зависимости от того, был ли цикл завершен раньше (с помощью перемена оператор) или нет, используя предложение else с циклом. Например,

за п в set_of_numbers:    если простой(п):        Распечатать(«Набор содержит простое число»)        переменаеще:    Распечатать(«Набор не содержит простых чисел»)

В еще предложение в приведенном выше примере связано с за заявление, а не внутренний если утверждение. Оба Python за и пока Циклы поддерживают такое предложение else, которое выполняется только в том случае, если не произошло раннего выхода из цикла.

Некоторые языки поддерживают выход из вложенных циклов; в теоретических кругах это называется многоуровневыми перерывами. Один из распространенных примеров использования - поиск в многомерной таблице. Это можно сделать либо через многоуровневые перерывы (прорыв из N уровни), как в bash^[9] и PHP,^[10] или через помеченные разрывы (прервать и продолжить с заданной меткой), как в Java и Perl.^[11] Альтернативы многоуровневым разрывам включают одиночные разрывы вместе с переменной состояния, которая проверяется для выхода на другой уровень; исключения, которые вылавливаются на разбитом уровне; размещение вложенных циклов в функции и использование return для завершения всего вложенного цикла; или используя метку и инструкцию goto. C не включает многоуровневый разрыв, и обычная альтернатива - использовать goto для реализации помеченного разрыва.^[12] Python не имеет многоуровневого прерывания или продолжения - это было предложено в PEP 3136, и отклонили на том основании, что дополнительная сложность не стоит редкого законного использования.^[13]

Понятие многоуровневых разрывов представляет некоторый интерес в теоретическая информатика, потому что это дает начало тому, что сегодня называется Иерархия Косараджу.^[14] В 1973 г. С. Рао Косараджу усовершенствовал теорема о структурированной программе доказав, что можно избежать добавления дополнительных переменных в структурированном программировании, пока разрешены многоуровневые разрывы произвольной глубины из циклов.^[15] Кроме того, Косараджу доказал, что существует строгая иерархия программ: для каждого целого числа п, существует программа, содержащая многоуровневый разрыв глубины п которую нельзя переписать как программу с многоуровневыми перерывами глубиной менее п без введения дополнительных переменных.^[14]

Можно также возвращаться вне подпрограммы, выполняющей зацикленные операторы, с выходом из вложенного цикла и подпрограммы. Есть другие предлагаемые структуры управления для множественных перерывов, но они обычно реализуются как исключения.

В своем учебнике 2004 г. Дэвид Ватт использует понятие Теннента о секвенсор чтобы объяснить сходство между многоуровневыми разрывами и операторами возврата. Ватт отмечает, что класс секвенсоров, известный как escape-последовательности, определяемый как «секвенсор, который завершает выполнение команды или процедуры, содержащей текст», включает в себя как разрывы из циклов (включая многоуровневые разрывы), так и операторы возврата. Однако, как обычно реализовано, секвенсоры возврата также могут нести (возвращаемое) значение, тогда как секвенсор прерывания, реализованный в современных языках, обычно не может.^[16]

Варианты и инварианты петель

Варианты петель и инварианты цикла используются для выражения правильности петель.^[17]

На практике вариант цикла - это целочисленное выражение, имеющее начальное неотрицательное значение. Значение варианта должно уменьшаться во время каждой итерации цикла, но никогда не должно становиться отрицательным при правильном выполнении цикла. Варианты цикла используются, чтобы гарантировать, что цикл завершится.

Инвариант цикла - это утверждение, которое должно быть истинным до первой итерации цикла и оставаться истинным после каждой итерации. Это означает, что при правильном завершении цикла удовлетворяются как условие выхода, так и инвариант цикла. Инварианты цикла используются для отслеживания определенных свойств цикла во время последовательных итераций.

Некоторые языки программирования, например Эйфель содержат встроенную поддержку вариантов и инвариантов цикла. В других случаях поддержка - это надстройка, например Язык моделирования Java спецификация для операторы цикла в Ява.

Подъязык цикла

Немного Лисп диалекты предоставляют обширный подъязык для описания циклов. Ранний пример можно найти в Conversional Lisp из Интерлисп. Common Lisp^[18] предоставляет макрос Loop, который реализует такой подъязык.

Таблица перекрестных ссылок петлевой системы

Было предложено, чтобы эта статья была расколоть в новую статью под названием Сравнение языков программирования (поток управления). (Обсуждать) (Май 2016)

1. ^а пока (правда) не считается бесконечным циклом для этой цели, потому что это не специальная языковая структура.
2. ^{а б c d е ж грамм час} C за (в этом; тест; приращение) loop - это общая конструкция цикла, а не подсчитывающая, хотя она часто используется для этого.
3. ^{а б c} Глубокие перерывы могут быть выполнены в APL, C, C ++ и C # с помощью меток и gotos.
4. ^а Итерация по объектам была добавлен в PHP 5.
5. ^{а б c} Цикл подсчета можно смоделировать, перебирая увеличивающийся список или генератор, например, Python классифицировать().
6. ^{а б c d е} Глубокие перерывы могут быть достигнуты с помощью обработки исключений.
7. ^а Специальной конструкции нет, так как пока для этого можно использовать функцию.
8. ^а Специальной конструкции нет, но пользователи могут определять общие функции цикла.
9. ^а В C ++ 11 стандарт ввел на основе диапазона для. в STL, Существует std :: for_each шаблон функция, которая может выполнять итерацию по STL контейнеры и позвонить унарная функция для каждого элемента.^[19] Функциональность также может быть построена как макрос на этих контейнерах.^[20]
10. ^а Цикл, управляемый подсчетом, осуществляется итерацией через целочисленный интервал; досрочный выход с включением дополнительного условия выхода.
11. ^а Эйфель поддерживает зарезервированное слово повторить попытку, однако он используется в Обработка исключений, а не петлевое управление.
12. ^а Требует Язык моделирования Java (JML) язык спецификации поведенческого интерфейса.
13. ^а Требует, чтобы варианты цикла были целыми числами; трансфинитные варианты не поддерживаются. [1]
14. ^а D поддерживает бесконечные коллекции и возможность перебирать эти коллекции. Для этого не требуется особой конструкции.
15. ^а Глубоких разрывов можно добиться, используя ИДТИ К и процедуры.
16. ^а Common Lisp предшествует концепции универсального типа коллекции.

Структурированный нелокальный поток управления

Многие языки программирования, особенно те, которые предпочитают более динамические стили программирования, предлагают конструкции для нелокальный поток управления. Это заставляет поток выполнения выскакивать из данного контекста и возобновляться в некоторой заранее объявленной точке. Условия, исключения и продолжения являются тремя распространенными типами нелокальных управляющих конструкций; существуют и более экзотические, такие как генераторы, сопрограммы и асинхронный ключевое слово.

Условия

PL / I имеет около 22 стандартных условий (например, ZERODIVIDE SUBSCRIPTRANGE ENDFILE), которые могут быть вызваны и которые могут быть перехвачены: ON условие действие; Программисты также могут определять и использовать свои собственные именованные условия.

Словно неструктурированный, еслиможно указать только один оператор, поэтому во многих случаях требуется GOTO, чтобы решить, где следует возобновить поток управления.

К сожалению, некоторые реализации имели значительные накладные расходы как в пространстве, так и во времени (особенно SUBSCRIPTRANGE), поэтому многие программисты пытались избегать использования условий.

Общие примеры синтаксиса:

 НА условие ИДТИ К метка

Исключения

Современные языки имеют специализированную структурированную конструкцию для обработки исключений, которая не зависит от использования ИДТИ К или (многоуровневый) перерыв или возврат. Например, в C ++ можно написать:

пытаться {    xxx1                                  // Где-то здесь    xxx2                                  // использование: '' 'throw' '' someValue;    xxx3} ловить (someClass& someId) {             // поймать значение someClass    actionForSomeClass } ловить (someType& anotherId) {           // поймать значение someType    actionForSomeType} ловить (...) {                           // поймать то, что еще не поймано    actionForAnythingElse}

Любое количество и разнообразие ловить пункты можно использовать выше. Если нет ловить соответствие конкретному бросать, управление просачивается обратно через вызовы подпрограмм и / или вложенные блоки, пока не будет найдено соответствие ловить или до тех пор, пока не будет достигнут конец основной программы, после чего программа принудительно останавливается с соответствующим сообщением об ошибке.

Благодаря влиянию C ++, ловить - ключевое слово, зарезервированное для объявления обработчика исключений сопоставления с образцом в других популярных сегодня языках, например Java или C #. Некоторые другие языки, такие как Ada, используют ключевое слово исключение для введения обработчика исключений, а затем может даже использовать другое ключевое слово (когда в Аде) для сопоставления с образцом. Несколько языков вроде AppleScript включить заполнители в синтаксис обработчика исключений, чтобы автоматически извлекать несколько фрагментов информации при возникновении исключения. Этот подход иллюстрируется ниже на примере по ошибке построить из AppleScript:

пытаться    набор мой номер к мой номер / 0на ошибка е  номер п  из ж  к т  частичный результат пр    если ( е = «Нельзя делить на ноль» ) тогда диалог отображения "Вы не должны этого делать"конец пытаться

В учебнике Дэвида Ватта 2004 г. также анализируется обработка исключений в рамках секвенсоров (представленных в этой статье в разделе о ранних выходах из циклов). Ватт отмечает, что ненормальная ситуация, обычно иллюстрируемая арифметическими переполнениями или ввод, вывод сбои типа «файл не найден» - это своего рода ошибка, которая «обнаруживается в некоторой программной единице низкого уровня, но [для которой] обработчик более естественно расположен в программной единице высокого уровня». Например, программа может содержать несколько вызовов для чтения файлов, но действие, которое нужно выполнить, когда файл не найден, зависит от значения (цели) файла, о котором идет речь, для программы, и, следовательно, процедура обработки этой ненормальной ситуации не может быть находится в системном коде нижнего уровня. Уоттс далее отмечает, что введение тестирования флагов состояния в вызывающей программе, как это повлечет за собой структурированное программирование с одним выходом или даже секвенсоры возврата (с несколькими выходами), приводит к ситуации, когда «код приложения имеет тенденцию загромождаться тестами флагов состояния» и что «программист может по забывчивости или лениво пропустить проверку флага состояния. Фактически, ненормальные ситуации, представленные флагами состояния, по умолчанию игнорируются!» Ватт отмечает, что в отличие от тестирования флагов состояния, исключения имеют обратное поведение по умолчанию, в результате чего программа завершается, если программист явно не обрабатывает исключение каким-либо образом, возможно, путем добавления явного кода для его игнорирования. Основываясь на этих аргументах, Ватт приходит к выводу, что секвенсоры перехода или управляющие секвенсоры не так подходят, как выделенный секвенсор исключений с семантикой, описанной выше.^[21]

В Object Pascal, D, Java, C # и Python наконец-то предложение может быть добавлено к пытаться построить. Независимо от того, как контроль оставляет пытаться код внутри наконец-то условие гарантированно выполнено. Это полезно при написании кода, который должен отказаться от дорогостоящего ресурса (такого как открытый файл или соединение с базой данных) по завершении обработки:

FileStream stm = ноль;                    // Пример C #пытаться {    stm = новый FileStream ("logfile.txt", FileMode.Создавать);    возвращаться ProcessStuff(stm);             // может вызвать исключение} наконец-то {    если (stm != ноль)        stm.Закрывать();}

Поскольку этот шаблон довольно распространен, C # имеет особый синтаксис:

с помощью (вар stm = новый FileStream("logfile.txt", FileMode.Создавать)){    возвращаться ProcessStuff(stm ); // может вызвать исключение}

При выходе из с помощью-block, компилятор гарантирует, что stm объект выпущен, эффективно привязка переменную в файловый поток, абстрагируясь от побочных эффектов инициализации и освобождения файла. Python с оператор и аргумент блока Ruby для File.open используются для аналогичного эффекта.

Все упомянутые выше языки определяют стандартные исключения и обстоятельства, при которых они возникают. Пользователи могут создавать собственные исключения; на самом деле C ++ позволяет пользователям бросать и ловить практически любой тип, включая базовые типы, такие как int, тогда как другие языки, такие как Java, не столь снисходительны.

Продолжение

Асинхронный

В C # 5.0 введено ключевое слово async для поддержки асинхронный ввод / вывод в «прямом стиле».

Генераторы

Генераторы, также известные как полупрограммы, позволяют временно передавать управление методу потребителя, обычно используя урожай ключевое слово (описание урожая ). Подобно ключевому слову async, он поддерживает программирование в «прямом стиле».

Сопрограммы

Сопрограммы - это функции, которые могут передавать друг другу контроль - форма кооперативная многозадачность без ниток.

Сопрограммы могут быть реализованы как библиотека, если язык программирования предоставляет либо продолжения, либо генераторы, поэтому различие между сопрограммами и генераторами на практике является технической деталью.

Перекрестная ссылка нелокального потока управления

Предлагаемые структуры управления

В пародии Датамация статья^[27] в 1973 г. Р. Лоуренс Кларк предложил заменить выражение GOTO на РОДОМ ИЗ заявление и предоставляет несколько интересных примеров. COMEFROM реализован в одном эзотерический язык программирования названный ИНТЕРКАЛ.

Дональд Кнут Статья 1974 г. "Структурированное программирование с использованием операторов перехода",^[28] определяет две ситуации, которые не были охвачены перечисленными выше управляющими структурами, и приводит примеры управляющих структур, которые могут справиться с этими ситуациями. Несмотря на их полезность, эти конструкции еще не нашли своего применения в основных языках программирования.

Петля с тестом посередине

Следующее было предложено Даль в 1972 г .:^[29]

   петля                           петля       xxx1 чтение (симв.); пока тест; пока нет atEndOfFile; xxx2 запись (символ); повторение;                        повторение;

Если xxx1 опускается, получаем цикл с тестом наверху (традиционный пока петля). Если xxx2 опускается, получаем цикл с тестом внизу, эквивалентный делать пока цикл на многих языках. Если пока опускается, получаем бесконечный цикл. Конструкцию здесь можно рассматривать как делать цикл с проверкой while посередине. Следовательно, эта единственная конструкция может заменить несколько конструкций в большинстве языков программирования.

Языки, в которых отсутствует эта конструкция, обычно эмулируют ее, используя эквивалентную идиому бесконечного цикла с разрывом:

пока (правда) {xxx1 если (нет тест) перемена    xxx2}

Возможный вариант - разрешить более одного пока тест; внутри цикла, но использование выход когда (см. следующий раздел), кажется, лучше охватывает этот случай.

В Ада, указанная выше конструкция цикла (петля-пока-повторение) можно представить с помощью стандартного бесконечного цикла (петля - конец цикла), имеющий выйти, когда предложение в середине (не путать с выход когда заявление в следующем разделе).

с Ada.Text_IO;с Ada.Integer_Text_IO;процедура Print_Squares является     Икс : Целое число;начинать    Read_Data : петля        Ада.Integer_Text_IO.Получать(Икс);    выход Read_Data когда Икс = 0;        Ада.Текст IO.Положить (Икс * Икс);        Ада.Текст IO.Новая линия;    конец петля Read_Data;конец Print_Squares;

Название цикла (например, Read_Data в этом примере) является необязательным, но позволяет выйти из внешнего цикла нескольких вложенных циклов.

Множественный ранний выход / выход из вложенных циклов

Это было предложено Зан в 1974 г.^[30] Здесь представлена ​​модифицированная версия.

   выход когда СобытиеA или же СобытиеB или же EventC; ххх выходы       СобытиеA: действиеA СобытиеB: действиеB СобытиеC: действиеC endexit;

выход когда используется для указания событий, которые могут произойти в ххх, их появление обозначается использованием имени события в качестве оператора. Когда какое-либо событие все же происходит, выполняется соответствующее действие, а затем управление переходит сразу после EndexitЭта конструкция обеспечивает очень четкое разделение между определением применимости некоторой ситуации и действиями, которые необходимо предпринять в этой ситуации.

выход когда концептуально похож на Обработка исключений, и исключения или аналогичные конструкции используются для этой цели на многих языках.

Следующий простой пример включает поиск определенного элемента в двумерной таблице.

   выход когда найденный или же отсутствующий; за I: = 1 к N делать           за J: = 1 к M делать               если таблица [I, J] = цель тогда найденный; отсутствующий; выходы       найдено: print («элемент в таблице»); отсутствует: print («товар отсутствует в таблице»); endexit;

Безопасность

Один из способов атаковать часть программного обеспечения - перенаправить поток выполнения программы. Разнообразие целостность потока управления методы, в том числе стек канареек, защита от переполнения буфера, теневые стеки и vtable проверка указателя, используются для защиты от этих атак.^[31][32][33]

Смотрите также

• Отрасль (информатика)
• Анализ потока управления
• Схема потока управления
• График потока управления
• Контрольный стол
• Coroutine
• Цикломатическая сложность
• Дракон-карта
• Схема
• ИДТИ К
• Джеру, помогает изучить управляющие структуры
• Основной цикл
• Рекурсия
• Планирование (вычисление)
• Код спагетти
• Структурированное программирование
• Подпрограмма
• Заявление о переключении, условно изменяет поток управления

Рекомендации

дальнейшее чтение

• Hoare, C. A. R. "Partition: Algorithm 63," "Quicksort: Algorithm 64," and "Find: Algorithm 65." Comm. ACM 4, 321-322, 1961.

внешняя ссылка

• СМИ, связанные с Поток управления в Wikimedia Commons
• Go To Statement Considered Harmful
• A Linguistic Contribution of GOTO-less Programming
• "Structured Programming with Go To Statements" (PDF). Архивировано из оригинал (PDF) on 2009-08-24. (2.88 MB)
• "IBM 704 Manual" (PDF). (31.4 MB)