Что такое цикл в программировании

Типы циклов в языках программирования: for, foreach, while и do while

Циклы — это основные управляющие конструкции в программировании. Они есть во всех современных языках. Рассказываем, какие бывают типы циклов.

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

Типы циклов

Цикл For

for (int i=0; i

i — это переменная-счётчик, которая сначала равна нулю. До тех пор, пока она меньше 10, выполняется тело цикла, затем счетчик увеличивается на единицу. For — цикл с предусловием. Это значит, что сначала проверяется условие, и если оно true, то тело выполняется. В скобках объявляется тип переменной счётчика и её начальное значение. Затем указывается условие конца цикла и способ, которым изменяется значение счётчика.

Цикл Foreach (или совместный цикл)

for (int element :array)

Тело этого цикла выполнится для каждого элемента коллекции. В переменной element будет доступен по очереди каждый элемент массива array.

Цикл While

while(i

Относится к тому же типу циклов, что и For, — цикл с предусловием. С его помощью можно создать безусловный цикл, например while(1) — бесконечный цикл. Чтобы его закончить, нужно использовать служебное слово break.

Цикл Do While

do < тело >while (i <10)

Do While относится к типу циклов с постусловием. Однако здесь код выполнится как минимум один раз, даже если условие false.

Вложенные циклы

int array[][] = , > for (i=0;i <3;i++) < for (j=0;j<3;j++) < printf(array[i][j]) >> 

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

Операторы циклов

Break

while (true) // бесконечный цикл < std::cout > val; // Выходим из цикла, если пользователь ввел 0 if (val == 0) break; > 

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

Continue

Оператор Continue даёт циклу команду выйти из текущей итерации и перейти к следующей.

Этот код выведет в консоль все нечетные числа из диапазона от 0 до 10:

for (int i = 0; i < 10; i++) < if (i % 2 == 0) < continue; >cout

Циклы и все, что нужно знать об их параметрах

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

На помощь в таких случаях приходят специальные конструкции. Они носят название циклов. В данной статье будет рассказано о том, как работают такие компоненты. А еще – какие параметры они имеют.

Цикл – это…

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

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

Есть еще и бесконечный цикл. Характеризуется непрерывным повторением фрагмента утилиты, которое будет вечным. Обычно вызывается ситуация условными операторами и функциями, перенаправляющими код обратно в «первоначальный блок». И так до бесконечности.

Составляющие

При записи рассматриваемого компонента можно выделить:

1. Тело цикла. Оно содержит выражения, операторы и иные инструкции, которые нужно будет выполнять. Можно назвать тело описанием. Реализовывается тогда, когда значение прописанного изначально условия имеет параметр true.
2. Заголовок. Он определяет, до каких пор или сколько раз тело выполняется.

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

Типы операторов цикла

В Pascal существуют разнообразные виды рассматриваемого компонента:

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

Блок с For

Название цикла For – «со счетчиком». Он применяется тогда, когда количество повторений напрямую связано с тем, что происходит непосредственно в теле. Именно такое определение дают поисковики и специализированная литература.

Оператор For приходит на помощь, когда количество повторений заранее известно.В заголовке указываются два значения:

1. Значение, которое получает переменная счетчик. От него начинается отсчет итераций. Он происходит шаг за шагом. Данный параметр равняется +1 на каждом новом «этапе».
2. Значение, которое будет отвечать за значение счетчика для остановки. Отражает количество итераций цикла.

Ниже – примеры того, в каких формах представления можно выразить в Pascal рассматриваемый «оператор».

Стоит обратить внимание на то, что если между начальным и конечным значением переменных счетчика стоит to – на каждом шаге значение увеличивается на +1. При downto происходит уменьшение на аналогичный параметр.

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

Изучая параметры и выполнение цикла в Pascal, стоит более детально рассмотреть каждую существующую схему «повторяющихся блоков». Эта информация поможет не запутаться в процессе создания уникальных крупных проектов.

Количество итераций в for определено еще до выполнения «петли». Ниже – примеры того, как клиент будет отвечать за соответствующий параметр. Значение тут присваивается переменной, после чего оно используется в заголовке. К этому моменту понятно, сколько «петля» повторится:

var i, n: integer; begin write('Сколько символов: '); readln(n); for i := 1 to n do write('*'); writeln; end.

Работа с While

While – это цикл с параметром, схема которого представлена выше. А именно – оператор с предусловием. В заголовке будет находиться логическое выражение. Когда оно возвращает «истину», тело выполняется. В противном случае – нет. Программа просто перейдет к следующему фрагменту в коде.

Здесь стоит обратить внимание на следующие моменты:

1. При выполнении тела ход программы снова возвращается к заголовку.
2. Описание условия выполнения тела снова проходит стадию проверки.
3. Выполнение осуществляется в «операторе» столько раз, сколько выражение логического характера возвращает себе «истину».
4. В теле важно предусматривать все корректировки переменных, используемых в заголовках. Сделать это так, чтобы когда-нибудь наступала ситуация логической лжи. Если пренебречь этим моментом, произойдет зацикливание.

Так, While повторит код число n раз, которое заранее неизвестно. Определение происходит непосредственно по мере работы контента. Ниже – примеры выполнения соответствующего оператора.

С repeat

Рассматривая параметры циклов, стоит обратить внимание на так называемый оператор с repeat. While может не выполняться, если логическое выражение в заголовке сразу получило false. Но это не всегда удобно и применимо на практике.

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

1. Оператор repeat предусматривает логическое условие после тела петли.
2. Если параметр – false, приложение выполнит требование. В противном случае – нет.

Второй описанный момент – это ключевая разница, которую имеет пара while-repeat. Вот – пример использования цикла с параметром в случае с repeat:

Выход

Для того, чтобы выходить из петли в Pascal, есть несколько процедур:

1. Break. Он отвечает за досрочное прекращение выполнения петли в написанной программе.
2. Continue. Параметр в цикле, который позволяет выйти из текущей итерации. Сама петля не завершится. Она всего лишь перейдет к последующей стадии.

Вот – пример того, как происходит настройка отображения степени двойки в Pascal. Это – всего лишь фрагмент, который обычно рассматривается новичками.

Выше – результат работы с операторами и петлями.

Как быстро разобраться в теме

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

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

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

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

Хотите освоить современную IT-специальность? Огромный выбор курсов по востребованным IT-направлениям есть в Otus !

Цикл (программирование)

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

Определения

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

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

Виды циклов

Безусловные циклы

Иногда в программах используются циклы, выход из которых не предусмотрен логикой программы. Такие циклы называются безусловными, или бесконечными. Специальных синтаксических средств для создания бесконечных циклов, ввиду их нетипичности, языки программирования не предусматривают, поэтому такие циклы создаются с помощью конструкций, предназначенных для создания обычных (или условных) циклов. Для обеспечения бесконечного повторения проверка условия в таком цикле либо отсутствует (если позволяет синтаксис, как, например, в цикле LOOP…END LOOP языка Ада), либо заменяется константным значением (while true do … в Паскале). В языке С используется цикл for(;;) с незаполненными секциями.

Цикл с предусловием

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

while do begin end; 

while(условие>)  тело цикла> > 

Цикл с постусловием

Цикл с постусловием — цикл, в котором условие проверяется после выполнения тела цикла. Отсюда следует, что тело всегда выполняется хотя бы один раз. В языке Паскаль этот цикл реализует оператор repeat..until; в Си — do…while.
На языке Pascal цикл с постусловием имеет следующий вид::

repeat until

do  тело цикла> > while(условие продолжения цикла>) 

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

Цикл с выходом из середины

Цикл с выходом из середины — наиболее общая форма условного цикла. Синтаксически такой цикл оформляется с помощью трёх конструкций: начала цикла, конца цикла и команды выхода из цикла. Конструкция начала маркирует точку программы, в которой начинается тело цикла, конструкция конца — точку, где тело заканчивается. Внутри тела должна присутствовать команда выхода из цикла, при выполнении которой цикл заканчивается и управление передаётся на оператор, следующий за конструкцией конца цикла. Естественно, чтобы цикл выполнился более одного раза, команда выхода должна вызываться не безусловно, а только при выполнении условия выхода из цикла.

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

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

Часть языков программирования содержат специальные конструкции для организации цикла с выходом из середины. Так, в языке Ада для этого используется конструкция LOOP…END LOOP и команда выхода EXIT или EXIT WHEN:

LOOP . Часть тела цикла EXIT WHEN ; . Часть тела цикла IF THEN EXIT; END; . Часть тела цикла END LOOP:

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

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

Цикл со счётчиком

Цикл со счётчиком — цикл, в котором некоторая переменная изменяет своё значение от заданного начального значения до конечного значения с некоторым шагом, и для каждого значения этой переменной тело цикла выполняется один раз. В большинстве процедурных языков программирования реализуется оператором for, в котором указывается счётчик (так называемая «переменная цикла»), требуемое количество проходов (или граничное значение счётчика) и, возможно, шаг, с которым изменяется счётчик. Например, в языке Оберон-2 такой цикл имеет вид:

FOR v := b TO e BY s DO . тело цикла END 

(здесь v — счётчик, b — начальное значение счётчика, e — граничное значение счётчика, s — шаг).

Неоднозначен вопрос о значении переменной по завершении цикла, в котором эта переменная использовалась как счётчик. Например, если в программе на языке Паскаль встретится конструкция вида:

i := 100; for i := 0 to 9 do begin . тело цикла end; k := i; 

возникает вопрос: какое значение будет в итоге присвоено переменной k: 9, 10, 100, может быть, какое-то другое? А если цикл завершится досрочно? Ответы зависят от того, увеличивается ли значение счётчика после последней итерации и не изменяет ли транслятор это значение дополнительно. Ещё один вопрос: что будет, если внутри цикла счётчику будет явно присвоено новое значение? Различные языки программирования решают данные вопросы по-разному. В некоторых поведение счётчика чётко регламентировано. В других, например, в том же Паскале, стандарт языка не определяет ни конечного значения счётчика, ни последствий его явного изменения в цикле, но не рекомендует изменять счётчик явно и использовать его по завершении цикла без повторной инициализации. Программа на Паскале, игнорирующая эту рекомендацию, может давать разные результаты при выполнении на разных системах и использовании разных трансляторов.

Радикально решён вопрос в языке Ада: счётчик считается описанным в заголовке цикла, и вне его просто не существует. Даже если имя счётчика в программе уже используется, внутри цикла в качестве счётчика используется отдельная переменная. Счётчику запрещено явно присваивать какие бы то ни было значения, он может меняться только внутренним механизмом оператора цикла. В результате конструкция

i := 100; for i in (0..9) loop . тело цикла end loop; k := i;

внешне аналогичная вышеприведённому циклу на Паскале, трактуется однозначно: переменной k будет присвоено значение 100, поскольку переменная i, используемая вне данного цикла, не имеет никакого отношения к счётчику i, который создаётся и изменяется внутри цикла. Подобное обособление счётчика удобно и безопасно: не требуется отдельное описание для него и минимальна вероятность случайных ошибок, связанных со случайным разрушением внешних по отношению к циклу переменных. Если программисту требуется включить в готовый код цикл со счётчиком, то он может не проверять, существует ли переменная с именем, которое он выбрал в качестве счётчика, не добавлять описание нового счётчика в заголовок соответствующей процедуры, не пытаться использовать один из имеющихся, но в данный момент «свободных» счётчиков. Он просто пишет цикл с переменной-счётчиком, имя которой ему удобно, и может быть уверен, что никакой коллизии имён не произойдёт.

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

В некоторых языках, например, Си и других, произошедших от него, цикл for, несмотря на синтаксическую форму цикла со счётчиком, в действительности является циклом с предусловием. То есть в Си конструкция цикла:

for (i = 0; i  10; ++i)  . тело цикла > 

фактически представляет собой другую форму записи конструкции [1] :

i = 0; while (i  10)  . тело цикла ++i; > 

То есть в конструкции for сначала пишется произвольное предложение инициализации цикла, затем — условие продолжения и, наконец, выполняемая после каждого тела цикла некоторая операция (это не обязательно должно быть изменение счётчика; это может быть правка указателя или какая-нибудь совершенно посторонняя операция). Для языков такого вида вышеописанная проблема решается очень просто: переменная-счётчик ведёт себя совершенно предсказуемо и по завершении цикла сохраняет своё последнее значение.

Совместный цикл

Ещё одним вариантом цикла является цикл, задающий выполнение некоторой операции для объектов из заданного множества, без явного указания порядка перечисления этих объектов. Такие циклы называются совместными (а также циклами по коллекции, циклами просмотра) и представляют собой формальную запись инструкции вида: «Выполнить операцию X для всех элементов, входящих во множество M». Совместный цикл, теоретически, никак не определяет, в каком порядке операция будет применяться к элементам множества, хотя конкретные языки программирования, разумеется, могут задавать конкретный порядок перебора элементов. Произвольность даёт возможность оптимизации исполнения цикла за счёт организации доступа не в заданном программистом, а в наиболее выгодном порядке. При наличии возможности параллельного выполнения нескольких операций возможно даже распараллеливание выполнения совместного цикла, когда одна и та же операция одновременно выполняется на разных вычислительных модулях для разных объектов, при том что логически программа остаётся последовательной.

Совместные циклы имеются в некоторых языках программирования (C#, Eiffel, Java, JavaScript, Perl, Python, PHP, LISP, Tcl и др.) — они позволяют выполнять цикл по всем элементам заданной коллекции объектов. В определении такого цикла требуется указать только коллекцию объектов и переменную, которой в теле цикла будет присвоено значение обрабатываемого в данный момент объекта (или ссылка на него). В различных языках программирования синтаксис оператора различен:

for (type &item : set) //поддерживается, начиная со стандарта C++11  //использование item > 

foreach (type item in set)  //использование item > 

for item in [1..100] do begin //Использование item (Работоспособность кода проверялась в Delphi 2010) end; 

Perl (строгий порядок "от первого до последнего"):

foreach (@set)  #использование $_ > # или for (@set)  #использование $_ > # или foreach $item (@set)  #использование $item > 

across set as cursor loop -- использование cursor.item end 

for (type item : set)  //использование item > 

for (txtProperty in objObject)  /* использование: objObject [txtProperty] */ > 

foreach ($arr as $item)  /* использование $item*/ > //или foreach ($arr as $key=>$value)  /* использование значений индекса $key и его значения $value*/ > 

For Each item As type In set 'использование item Next item

foreach ($item in $set)
$set | ForEach-Object

for item in iterator_instance: # использование item 

Досрочный выход и пропуск итерации

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

Досрочный выход из цикла

Команда досрочного выхода применяется, когда необходимо прервать выполнение цикла, в котором условие выхода ещё не достигнуто. Такое бывает, например, когда при выполнении тела цикла обнаруживается ошибка, после которой дальнейшая работа цикла не имеет смысла.

Команда досрочного выхода обычно называется EXIT или break , а её действие аналогично действию команды безусловного перехода ( goto ) на команду, непосредственно следующую за циклом, внутри которого эта команда находится. Так, в языке Си два нижеприведённых цикла работают совершенно одинаково:

// Применение оператора break while(условие>)  . операторы if (ошибка>) break; . операторы > . продолжение программы // Аналогичный фрагмент без break while(условие>)  . операторы if (ошибка>) goto break_label; . операторы > break_label: . продолжение программы

В обоих случаях, если в теле цикла выполнится условие , будет произведён переход на операторы, обозначенные как «продолжение программы». Таким образом, оператор досрочного выхода из цикла, по сути, просто маскирует безусловный переход, однако использование break предпочтительнее, чем goto, поскольку поведение break чётко задано языком, потенциально менее опасно (нет, например, вероятности ошибиться с положением или названием метки). Кроме того, явный досрочный выход из цикла не нарушает принципов структурного программирования.

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

Пропуск итерации

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

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

int arr[ARRSIZE]; . // Суммирование отдельно всех и только положительных // элементов массива arr с применением continue. int sum_all = 0; int sum_pos = 0; for (int i = 0 ; i  ARRSIZE; ++i)  sum_all += arr[i]; if (arr[i]  0) continue; sum_pos += arr[i]; > // Аналогичный код c goto int sum_all = 0; int sum_pos = 0; for (int i = 0 ; i  ARRSIZE; ++i)  sum_all += arr[i]; if (arr[i]  0) goto cont_label; sum_pos += arr[i]; cont_label: > 

Из второго фрагмента ясно видно, как работает continue : он просто передаёт управление за последнюю команду тела цикла, пропуская выполнение команды суммирования, если очередной элемент массива не удовлетворяет условию. Таким образом, в sum_pos накапливается сумма лишь положительных элементов массива.

Необходимость

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

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

// Досрочный выход из цикла без break bool flag = false; // флаг досрочного завершения while(условие> && !flag)  . операторы if (ошибка>)  flag = true; > else  . операторы > > . продолжение программы

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

Несколько иначе обстоит дело с командой пропуска итерации. Она, как правило, очень легко и естественно заменяется на условный оператор. Например, приведённый выше фрагмент суммирования массива можно записать так:

int arr[ARRSIZE]; . // Суммирование отдельно всех и только положительных // элементов массива arr с заменой continue int sum_all = 0; int sum_pos = 0; for (int i = 0 ; i  ARRSIZE; ++i)  sum_all += arr[i]; if (arr[i] > 0) // Условие заменено на противоположное!  sum_pos += arr[i]; > > 

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

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

int arr[ARRSIZE]; . int sum_all = 0; int sum_pos = 0; int i = 0; while (i  ARRSIZE) // Цикл внешне аналогичен предыдущему for .  sum_all += arr[i]; if (arr[i]  0) continue; sum_pos += arr[i]; ++i; // . но эта команда будет пропущена при выполнении continue // и программа зациклится > 

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

Вложенные циклы

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

Полное число исполнений тела внутреннего цикла не превышает произведения числа итераций внутреннего и всех внешних циклов. Например взяв три вложенных друг в друга цикла, каждый по 10 итераций, получим 10 исполнений тела для внешнего цикла, 100 для цикла второго уровня и 1000 в самом внутреннем цикле.

Одна из проблем, связанных с вложенными циклами — организация досрочного выхода из них. Во многих языках программирования есть оператор досрочного завершения цикла (break в Си, exit в Турбо Паскале, last в Perl и т. п.), но он, как правило, обеспечивает выход только из цикла того уровня, откуда вызван. Вызов его из вложенного цикла приведёт к завершению только этого внутреннего цикла, внешний же цикл продолжит выполняться. Проблема может показаться надуманной, но она действительно иногда возникает при программировании сложной обработки данных, когда алгоритм требует немедленного прерывания в определённых условиях, наличие которых можно проверить только в глубоко вложенном цикле.

Решений проблемы выхода из вложенных циклов несколько.

• Простейший — использовать оператор безусловного перехода goto для выхода в точку программы, непосредственно следующую за вложенным циклом. Этот вариант критикуется сторонниками структурного программирования, как и все конструкции, требующие использования goto. Некоторые языки программирования, например, Модула-2, просто, не имеют оператора безусловного перехода, и в них подобная конструкция невозможна.
• Альтернатива — использовать штатные средства завершения циклов, в случае необходимости устанавливая специальные флаги, требующие немедленного завершения обработки. Недостаток — усложнение кода, снижение производительности.
• Размещение вложенного цикла в процедуре. Идея состоит в том, чтобы всё действие, которое может потребоваться прервать досрочно, оформить в виде отдельной процедуры, и для досрочного завершения использовать оператор выхода из процедуры (если такой есть в языке программирования). В языке Си, например, можно построить функцию с вложенным циклом, а выход из неё организовать с помощью оператора return. Недостаток — выделение фрагмента кода в процедуру не всегда логически обосновано, и не все языки имеют штатные средства досрочного завершения процедур.
• Воспользоваться механизмом генерации и обработки исключений (исключительных ситуаций), который имеется сейчас в большинстве языках высокого уровня. В этом случае в нештатной ситуации код во вложенном цикле возбуждает исключение, а блок обработки исключений, в который помещён весь вложенный цикл, перехватывает и обрабатывает его. Недостаток — реализация механизма обработки исключений в большинстве случаев такова, что скорость работы программы уменьшается. Правда, в современных условиях это не особенно важно: практически потеря производительности столь мала, что имеет значение лишь для очень немногих приложений.
• Наконец, существуют специальные языковые средства для выхода из вложенных циклов. Так, в языке Ада программист может пометить цикл (верхний уровень вложенного цикла) меткой, и в команде досрочного завершения цикла указать эту метку. Выход произойдёт не из текущего цикла, а из всех вложенных циклов до помеченного, включительно [2] . Язык PHP предоставляет возможность указать число прерываемых циклов после команды break — так break 2 прервёт сам цикл и вышестоящий над ним, а break 1 эквивалентно простой записи команды break [3] .

Циклы с несколькими охраняемыми ветвями

Цикл Дейкстры

В теории программирования известна ещё одна, принципиально отличающаяся от «классических», форма циклической конструкции, получившая название «цикл Дейкстры», по имени Эдсгера Дейкстры, впервые её описавшего. В классическом дейкстровском описании такой цикл выглядит следующим образом:

do P1 → S1, … Pn → Sn od

Здесь do — маркер начала конструкции цикла, od — маркер завершения конструкции цикла, P_i — i-тое охраняющее условие (логическое выражение, которое может иметь значение «истинно» или «ложно»), S_i — i-я охраняемая команда. Цикл состоит из одной или нескольких ветвей (охраняемых выражений), каждая из которых представляет собой пару из охраняющего условия (или, коротко, «охраны») и охраняемой команды (понятно, что в реальности команда может быть сложной).

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

Хотя цикл Дейкстры был изобретён ещё в 1970-х годах, специальных конструкций для его создания в языках программирования не содержится. Единственным исключением стал недавно созданный Оберон-07 — первый реальный язык программирования, явно поддерживающий цикл с несколькими охраняемыми ветвями. Впрочем, цикл Дейкстры может быть без больших затруднений смоделирован с помощью традиционных конструкций структурных языков программирования. Вот пример его реализации одним из возможных способов на языке Ада:

loop if P1 then S1; . elsif Pn then Sn; else exit; end if; end loop;

Здесь P1-Pn — охраняющие условия, а S1-Sn — соответствующие охраняемые команды.

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

Цикл «паук»

Легко видеть, что цикл Дейкстры не содержит явного условия продолжения или выхода, что не всеми теоретиками программирования рассматривается как благо. Поэтому была предложена усложнённая конструкция цикла Дейкстры, получившая название «цикл-'паук'». В той же нотации она выглядит следующим образом:

do P1→S1, … Pn→Sn out Q1→T1, … Qn→Tn else E od

Здесь после маркера out добавлены ветви завершения, состоящие из условий выхода Q_i и команд завершения T_i. Кроме того, добавлена ветвь альтернативного завершения else с командой E.

Цикл-'паук' выполняется так:

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

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

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

Интересные факты

• Никлаус Вирт одно время называл цикл со счётчиком «маргинальным», утверждая, что такая конструкция является излишней и должна быть исключена из синтаксиса языков программирования как несистемная. В соответствии с этим представлением в языке программирования Оберон цикла со счётчиком не было. Однако в языке Оберон-2, созданном Виртом и Мёссенбёком в развитие Оберона, цикл со счётчиком FOR появился снова в интересах практического удобства использования [4] .

См. также

• Инварианты цикла (используются при проектировании и верификации циклов)
• Рекурсия
• Итератор (программирование)

Методы оптимизации циклов

• Loop tiling
• Loop unrolling
• Loop unswitching

Примечания

1. ↑ Строго говоря, тождество не полное, так как по-другому будет работать оператор continue.
2. ↑Loops/Nested at Rosetta Code (англ.)
3. ↑PHP Manual, break (англ.)
4. ↑Оберон — воплощение мечты Никлауса Вирта

Ссылки

• Подробное описание циклических процессов в Паскале
• Работа с циклами for и foreach в PHP

Цикл

Цикл в программировании — это управляющая конструкция, которая заставляет какой-то блок кода выполняться несколько раз. Циклы есть в большинстве языков программирования. Чаще всего их объявляют командами for, while или repeat.

«IT-специалист с нуля» — наш лучший курс для старта в IT

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

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

Профессия / 8 месяцев
IT-специалист с нуля

Попробуйте 9 профессий за 2 месяца и выберите подходящую вам

Кто и зачем пользуется циклами

Циклы встречаются в работе большинства программистов практически на всех языках программирования. Они есть в Java, JavaScript, PHP, Python, C++ — везде. Циклов в привычном виде нет разве что в очень низкоуровневых языках, близких к «железу», таких как ассемблер.

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

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

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

Частичной альтернативой циклам в программировании можно назвать некоторые встроенные функции высшего порядка. Они могут выполнять несколько действий, например с массивом. Но такие функции есть не во всех языках и подходят не для всего. Циклы универсальнее.

Какими бывают циклы

Обычно в языках программирования несколько видов циклов. У каждого из них свое назначение. Разберемся с основными.

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

Объявление переменной — это создание итератора, переменной, которая будет изменяться на каждом шаге цикла. Когда итератор достигнет какого-то значения, цикл закончится.

Условие описывает, должен ли цикл продолжаться. Пока оно выполняется, цикл работает. Чаще всего условие — итератор меньше или больше определенного числа. Соответственно, когда итератор достигает указанного значения, цикл останавливается.

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

Стандартный случай — задается итератор, равный 0. Условие — итератор меньше какого-нибудь N. Действие — прибавить к итератору единицу. Цикл будет выполняться N+1 раз, потому что отсчет идет с нуля. Есть и вариации, их рассмотрим ниже.

В некоторых языках, таких как Python или Pascal, синтаксис цикла For другой. Но суть та же: им пользуются, когда нужное количество действий известно заранее.

Курс для новичков «IT-специалист
с нуля» – разберемся, какая профессия вам подходит, и поможем вам ее освоить

For in / for of / for-each. Частный случай цикла for — когда нужно пройти по структуре данных. Для этого в некоторых языках существует особая конструкция. Это цикл for, который вместо итератора работает с самой структурой данных, например массивом или объектом.

В JavaScript такой цикл называется for of (есть еще for in, но он работает немного иначе), в Java — for-each, в Python — for in. Синтаксис примерно такой:

for in*  < > * in приведено для примера. В JS там не in, а of, а в Java и C++ — вообще двоеточие.

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

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

Не стоит путать этот цикл с функцией forEach(). Она проходит по массиву и что-то делает с каждым его элементом. Но это не цикл, а одна из функций высшего порядка, о которых мы говорили ранее.

While с предусловием. While — совсем другой случай. Это цикл, который используют, если нужное количество действий заранее неизвестно. Он может выполниться несколько раз, один раз, бесконечное количество раз — или вообще не выполниться ни разу. Слово while переводится как «пока» и отражает суть: пока верно какое-то условие, цикл выполняется.

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

while () < >

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

While с постусловием. Это вариация цикла while. Ее единственное отличие — условие пишется не до, а после тела цикла:

do < > while ();

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

Repeat / until. В некоторых языках есть еще один вид цикла — repeat или until. Он похож на while, но, в отличие от него, описывает не условие для продолжения, а условие для выхода из цикла. Цикл закончится, когда условие окажется верным.

В Pascal это цикл с постусловием, который описывается так:

repeat < > until (); А, например, в Perl это цикл с предусловием: until () < >

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

Как можно модифицировать циклы

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

Цикл по структуре данных. Это цикл for in / for of, о котором мы уже говорили. Обычным циклом тоже можно пройти по массиву: запустить счетчик от 0 до длины структуры данных. Но тут есть детали, которые стоит прояснить подробнее.

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

Если структура не итерируемая, то пройти по ней циклом for in / for of обычно нельзя. В большинстве языков программирования это работает именно так.

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

Курс для новичков «IT-специалист
с нуля» – разберемся, какая профессия вам подходит, и поможем вам ее освоить

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

Кстати, повернуть цикл for в другую сторону — не единственная его модификация. Можно, например, сделать цикл с шагом 2 и больше, чтобы итератор изменялся не на 1, а на 2 или другое число. Можно вообще не складывать с ним или вычитать из него числа, а умножать или делить. Вариаций много. Но используют их не так часто, чтобы не усложнять код: хорошая практика — делать программу понятной и легко читаемой.

Вложенный цикл. Его иногда называют двойным циклом. Это цикл, в который вложен другой цикл. Чаще всего это цикл for.

Тело внешнего цикла — внутренний цикл. А уже внутри могут быть разные подпрограммы.

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

На каждом шаге внешнего цикла выполняется весь внутренний, целиком. Если внешний цикл происходит N раз, а внутренний — M раз, то общее количество итераций во вложенном цикле — N * M. Это много. Поэтому вложенные циклы ресурсоемкие, и ими пользуются, только если без них не обойтись. К тому же конструкция из двух циклов друг в друге серьезно усложняет читаемость кода.

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

Бесконечным чаще всего становится цикл while, но в теории таким можно сделать и цикл for — например, если не менять итератор или установить невозможное условие для выхода.

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

Как прервать цикл

Существует несколько способов остановить выполнение цикла. Чаще всего используют тот, который предусмотрен самой конструкцией, — невыполнение условия. Но есть и другие возможности. Пользоваться ими не всегда корректно.

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

Условия могут быть разными, в том числе сложными, состоящими из нескольких частей. Ниже мы расскажем про break и continue — в большинстве случаев грамотно составленные условия помогают обойтись без использования этих операторов.

Пропуск итерации. Если по какой-то причине в цикле нужно закончить итерацию раньше времени и перейти на следующую, для этого есть специальная команда. Обычно она называется continue. По сути, это оператор, который говорит программе: «Закончи это повторение, продолжи со следующего шага».

Continue нужно просто написать в том месте, где вы хотите выйти из текущей итерации, — например, если в программе выполнилось какое-то условие.

На практике continue используется не слишком часто, во многих языках его считают плохой практикой. Его можно заменить условным оператором.

Выход из цикла. Можно экстренно выйти из цикла в любой момент. Для этого во многих языках программирования существует команда break. Она означает «Прерви выполнение подпрограммы и выйди из нее».

Когда программа доходит до этой команды, она выходит из цикла или условия и начинает выполнять код, который идет дальше. Никаких итераций больше не происходит. Например, мы искали в цикле какое-то число, нашли его — дальше проходить по циклу не нужно. Можно из него выйти.

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

Команду можно использовать не только в циклах, но и, например, в условных структурах if/else.

Пауза. Некоторые языки дают возможность временно приостановить цикл, как бы установить задержку для его выполнения. Например, подождать несколько секунд — для этого есть специальные функции. Как реализовать такую возможность, зависит от языка и ситуации.

Что нужно знать при использовании циклов

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

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

Пользоваться операторами break и continue без нужды — плохая практика в большинстве языков программирования. Они нарушают структуру программы, делают код менее логичным и предсказуемым.

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

Хотите узнать больше про языки программирования? Запишитесь на курсы и станьте разработчиком на одном из востребованных современных языков.

IT-специалист с нуля

Наш лучший курс для старта в IT. За 2 месяца вы пробуете себя в девяти разных профессиях: мобильной и веб-разработке, тестировании, аналитике и даже Data Science — выберите подходящую и сразу освойте ее.