Что такое оператор цикла

Что такое оператор цикла

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

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

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

В языке Free Pascal для удобства программиста предусмотрены три оператора, реализующих циклический процесс: while, repeat… until и for.

Оператор цикла с предусловием while .. do

Оператор, реализующий этот алгоритм в языке Free Pascal, имеет вид:

while выражение do оператор;

здесь while .. do – зарезервированные слова языка Free Pascal, выражение – логическая константа, переменная или логическое выражение, оператор – любой допустимый оператор языка.

Работает оператор while следующим образом. Вычисляется значение выражения. Если оно истинно (True), выполняется оператор. В противном случае цикл заканчивается, и управление передается оператору, следующему за телом цикла. Выражение вычисляется перед каждой итерацией цикла. Если при первой проверке выражение ложно (False), цикл не выполнится ни разу.

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

Операторы цикла For и While. Операторы Break и Continue

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

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

Часто операторы цикла используются при работе с массивами.

Так, вместо того чтобы писать:

 text += cars[0] + "
"; text += cars[1] + "
"; text += cars[2] + "
"; text += cars[3] + "
"; text += cars[4] + "
"; text += cars[5] + "
"; 

 var i; for (i = 0; i < cars.length; i++) < text += cars[i] + "
"; > 

Различные виды операторов цикла

JavaScript поддерживает различные виды циклов:

• for – в цикле выполняет блок кода заданное число раз
• for/in – цикл по свойствам объекта
• while – выполняет блок кода до тех пор, пока заданное условие не будет равно true
• do/while – также выполняет блок кода до тех пор, пока заданное условие не будет равно true

Оператор цикла for

Оператор for это наиболее часто используемый инструмент для создания цикла.

Оператор цикла for имеет следующий синтаксис:

for (выражение 1; выражение 2; выражение 3) выполняемый блок кода
>

Выражение 1 выполняется до начала цикла (до начала выполнения блока кода).
Выражение 2 определяет условие продолжения цикла.
Выражение 3 выполняется после каждого прохода цикла.

Пример:

 for (i = 0; i < 5; i++) < text += "Число: " + i + "
"; > 

Код этого примера можно прочитать следующим образом:

• выражение 1 до начала цикла инициализирует переменную-счетчик (var i = 0).
• выражение 2 определяет условие продолжения цикла (i должно быть меньше 5).
• выражение 3 после каждого прохода цикла увеличивает на 1 счетчик (i++).

Выражение 1
Обычно, выражение 1 используется для инициализации переменной, которая будет использоваться внутри цикла, как правило в качестве счетчика (i = 0).

При этом выражение 1 является необязательным.

Можно в выражении 1 инициализировать несколько переменных (разделяя их запятыми):

 for (i = 0, len = cars.length, text = ""; i < len; i++) < text += cars[i] + "
"; > 

Можно пропустить выражение 1 (и определить все необходимые значения до самого цикла):

 var i = 2; var len = cars.length; var text = ""; for (; i < len; i++) < text += cars[i] + "
"; > 

Выражение 2
Часто выражение 2 используется для вычисления состояния переменной-счетчика.

При этом выражение 2 также является необязательным.

Если выражение 2 возвращает true, то начнется новый цикл. Если оно вернет false, то цикл закончится.

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

Выражение 3
Обычно, в выражении 3 изменяется значение переменной-счетчика.

При этом выражение 3 также является необязательным.

Выражение 3 может выполнять любые действия, например, уменьшение (i—), увеличение (i = i + 15) и т.д.

Выражение 3 может быть пропущено (например, если вычисления с переменной-счетчиком осуществляются внутри цикла):

 var i = 0; var len = cars.length; for (; i < len; ) < text += cars[i] + "
"; i++; > 

Оператор цикла for/in

Оператор for/in используется для обхода в цикле свойств объекта:

 var person = ; var text = ""; var x; for (x in person)

Оператор цикла while

Оператор while в цикле выполняет блок кода до тех пор, пока заданное условие равно true.

while (условие) выполняемый блок кода
>

В следующем примере код цикла будет выполняться снова и снова, пока значение переменной (i) будет меньше 10:

 while (i

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

Оператор цикла do/while

Цикл do/while является вариантом цикла while. Этот цикл один раз выполнит блок кода перед проверкой условия завершения и затем будет повторять цикл до тех пор, пока условие не будет равно true.

do выполняемый блок кода
>
while (условие);

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

 do < text += "Число: " + i; i++; >while (i < 10); 

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

For vs While

Если вы внимательно изучили эту главу, то вы, вероятно, заметили, что оператор цикла while практически идентичен оператору цикла for, у которого не используются выражение 1 и выражение 3.

В следующем примере для вывода названий машин из массива cars используется оператор цикла for:

 var cars = ["BMW", "Volvo", "Saab", "Ford"]; var i = 0; var text = ""; for (;cars[i];) < text += cars[i] + "
"; i++; > 

В следующем примере для вывода названий машин из массива cars используется оператор цикла while:

 var cars = ["BMW", "Volvo", "Saab", "Ford"]; var i = 0; var text = ""; while (cars[i]) < text += cars[i] + "
"; i++; > 

Операторы break и continue

Оператор break позволяет "выпрыгнуть" из цикла.

Оператор continue позволяет "перепрыгнуть" через один проход цикла.

Оператор break

В предыдущих главах этого учебника вы уже встречались с оператором break. Он использовался для "выпрыгивания" из оператора условия switch.

Также, оператор break может использоваться и для "выпрыгивания" из цикла.

Оператор break прерывает цикл и передает выполнение коду, следующему после оператора цикла (если есть):

 for (i = 0; i < 10; i++) < if (i === 3) < break; >text += "Число: " + i + "
"; > 

Оператор continue

Оператор continue прекращает текущий проход цикла, если выполняется заданное условие, и начинает следующую итерацию цикла.

В следующем примере пропускается значение 3:

 for (i = 0; i < 10; i++) < if (i === 3) < continue; >text += "Число: " + i + "
"; > 

Метки

Чтобы определить метку в JavaScript, вы должны перед выражением указать имя метки с двоеточием:

метка:
выражение

Операторы break и continue единственные операторы в JavaScript, которые могут "выпрыгивать" из блока кода.

Оператор continue (с ссылкой на метку или без) единственный способ пропустить один проход цикла.

Оператор break (без ссылки на метку) единственный способ выйти из цикла или условного оператора switch.

Оператор break с ссылкой на метку позволяет выйти из любого блока кода и перейти в конкретное место программы:

 var cars = ["BMW", "Volvo", "Saab", "Ford"]; list: < text += cars[0] + "
"; text += cars[1] + "
"; text += cars[2] + "
"; break list; text += cars[3] + "
"; text += cars[4] + "
"; text += cars[5] + "
"; > 

Стоит напомнить, что блок кода — это код, расположенный внутри фигурных скобок < и >.

§ 5. Оператор цикла

Для записи оператора цикла с предусловием используется команда while. Формат команды:

while . Формат команды:

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

Пример 5.1. Написать программу, которая определит количество цифр в натуральном числе n.

Этапы выполнения задания

I. Исходные данные: n (заданное число).

II. Результат: k — количество цифр в числе.

III. Алгоритм решения задачи.

1. Ввод исходных значений.
2. Начальное значение переменной k = 0.
3. Чтобы посчитать количество цифр в числе, будем делить число на 10 до тех пор, пока число больше 1. Поскольку условие продолжения работы неизвестно, то будем использовать цикл while .
4. В цикле будем уменьшать число n в 10 раз и увеличивать значение k на 1.
5. Вывод результата.

Цикл while работает до тех пор, пока условие цикла истинно. Для того чтобы цикл завершил свою работу, в теле цикла должны быть команды, выполнение которых приведет к тому, что условие цикла станет ложным. Если таких команд нет, цикл выполняется бесконечно. Такую ситуацию называют зацикливанием. В случае зацикливания нужно прервать выполнение программы. В Code::Blocks для этого можно использовать кнопку .

using namespace std ;

while ( n > 0 )

///уменьшение числа в 10 раз

5.2. Оператор цикла с постусловием

Цикл, в котором условие для завершения работы проверяется после выполнения тела цикла, в С++ записывается следующим образом:

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

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

Пример 5.2. Написать программу, которая будет генерировать случайные числа из промежутка [1; x ] до тех пор, пока не будет сгенерировано число, кратное k . Вывести это число и количество сгенерированных чисел. Значения k и x вводятся ( k < x ).

Этапы выполнения задания

I. Исходные данные: числа k и r .

II. Результат: r (искомое число) и n (количество чисел).

III. Алгоритм решения задачи.

1. Ввод исходных значений.
2. Инициализация счетчика n = 0.
3. Поскольку нам известно условие окончания цикла — получить число, кратное k , то будем использовать цикл с постусловием. Условие можно записать так: ( r % k ). Если значение этого выражения не равно нулю, то условие истинно.

3.1. Генерируем случайное число r . В С++ для этого используется функция rand() , которая генерирует случайное число в промежутке [0; 32767). Это число будет использоваться в условии проверки окончания работы цикла.
3.2. Чтобы случайное число попало в промежуток [1; x ], найдем остаток от деления на x числа, сгенерированного функцией rand() , и прибавим к нему 1.
3.3. Увеличим значение счетчика на 1.

4. Вывод результата.

Числа, сгенерированные функцией rand() , называют псевдослучайными, поскольку при каждом запуске программы будет сгенерирована одна и та же последовательность чисел. Каждое новое число в последовательности генерируется по определенному алгоритму из предыдущего. Первое число в этой последовательности — константа, известная компилятору. Такой подход удобен для отладки программы. Однако для получения результатов необходимо при каждом запуске получать другие числа. Функция srand(n) из библиотеки cstdlib позволяет изменить первое число в последовательности в зависимости от значения параметра n . Однако, если значение n является константой, то последовательность чисел изменится по отношению к начальной, но не будет меняться при новых запусках программы. Если в качестве значения n взять системное время (функция time(NULL) из библиотеки ctime ), то при каждом запуске программы будем получать новую последовательность случайных чисел.

Пример 5.2.

using namespace std ;

Что такое оператор цикла

Операторы цикла задают многократное исполнение.

ОператорЦикла ::= while (Выражение) Оператор ::= for (ОператорИнициализацииFor [Выражение] ; [Выражение] )Оператор ::= do Оператор while (Выражение); ОператорИнициализацииFor ::= ОператорВыражение ::= Объявление 

Прежде всего, отметим эквивалентные формы операторов цикла.

for (ОператорИнициализацииFor [ВыражениеA] ;[ВыражениеB]) Оператор

ОператорИнициализацииFor while (ВыражениеA) < Оператор ВыражениеB ; >

Эти операторы называются операторами с предусловием.

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

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

Следует также обратить внимание на точку с запятой между двумя выражениями цикла for. В последнем примере они представлены символами ВыражениеA и ВыражениеB. Перед нами классический пример разделителя.

ОператорИнициализацииFor является обязательным элементом заголовка цикла. Обязательный оператор вполне может быть пустым.

Рассмотрим пример оператора цикла for:

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

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

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

Эта операция управляет последовательностью выполнения образующих оператор выражений.

• Прежде всего, выполняется оператор инициализации цикла. Если он не пустой, выражение за выражением, слева направо. Этот этап можно назвать этапом инициализации цикла. Он выполняется один раз, в самом начале работы цикла.
• Затем вычисляется значение выражения, которое располагается слева от оператора инициализации. Это выражение называется выражением условия продолжения цикла. Сам этап можно назвать этапом определения условий выполнимости.
• Если значение этого выражения отлично от нуля (т.е. истинно), выполняется оператор цикла. Этот этап можно назвать этапом выполнения тела цикла.
• После этого вычисляются значения выражений, которые располагаются слева от выражения условия продолжения цикла. Этот этап можно назвать этапом вычисления шага цикла.
• На последних двух этапах могут измениться значения ранее определённых переменных. А потому следующий цикл повторяется с этапа определения условий выполнимости.

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

int qwe; for (qwe < 10; ; ) <>// Оператор инициализатор построен на основе выражения сравнения. for (this; ; ) <> // Оператор инициализатор образован первичным выражением this. for (qwe; ; ) <> // Оператор инициализатор образован первичным выражением qwe. Ещё пример: int i = 0; int j; int val1 = 0; int val2; . i = 25; j = i*2; . for ( ; i

Мы имеем оператор цикла for, оператор инициализации которого пуст, а условие выполнения цикла основывается на значении переменной, которая была ранее объявлена и проинициализирована. Заголовок цикла является центром управления цикла. Управление циклом основывается на внешней по отношению к телу цикла информации.

for ( int i = 25, int j = i*2; i

Заголовок нового оператора содержит пару выражений, связанных операцией запятая. Тело оператора представляет всё тот же блок операторов. Что может содержать тело оператора? Любые операторы. Всё, что может называться операторами. От самого простого пустого оператора, до блоков операторов произвольной сложности! Этот блок живёт по своим законам. В нём можно объявлять переменные и константы, а поскольку в нём определена собственная область действия имён, то объявленные в блоке переменные и константы могут скрывать одноимённые объекты с более широкой областью действия имён.

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

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

Рассмотрим несколько примеров. Так, в ходе выполнения оператора цикла

int i; for (i = 0; i

десять раз будет выполняться оператор определения переменной j. Каждый раз это будут новые объекты. Каждый раз новой переменной заново будет присваиваться новое значение одной и той же переменной i, объявленной непосредственно перед оператором цикла for.

Объявление переменной i можно расположить непосредственно в теле оператора-инициализатора цикла:

for (int i = 0; i

И здесь возникает одна проблема. Дело в том, что тело оператора цикла for (оператор или блок операторов) имеет ограниченную область действия имён. А область действия имени, объявленного в операторе-инициализаторе, оказывается шире этой области.

Заголовок цикла for в C++ - центр управления циклом. Здесь следят за внешним миром, за тем, что происходит вне цикла. И потому все обращения к переменным и даже их новые объявления в заголовке цикла относятся к "внешней" области видимости. Следствием такого допущения (его преимущества далеко не очевидны) является правило соотнесения имени, объявленного в заголовке и области его действия.

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

А вот область действия имени переменной j при этом остаётся прежней.

В теле оператора for может быть определена одноимённая переменная:

for (int i = 0; i

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

Десять раз переменная i из оператора-инициализатора цикла будет заслоняться одноимённой переменной из оператора тела цикла. И всякий раз к нулю будет прибавляться нуль.

Ещё один пример. Два расположенных друг за другом оператора цикла for содержат ошибку

for (int i = 0, int j = 0; i < 100; i++, j--) < // Операторы первого цикла. >for (int i = 0, int k = 250; i < 100; i++, k--) < // Операторы второго цикла. >

Всё дело в том, что, согласно правилу соотнесения имён и областей действия имён в операторе цикла for, объявления переменных в заголовке цикла оказываются в общем пространстве имён. А почему, собственно, не приписать переменные, объявленные в заголовке цикла блоку, составляющему тело цикла? У каждого из альтернативных вариантов соотнесения имеются свои достоинства и недостатки. Однако выбор сделан, что неизбежно ведёт к конфликту имён и воспринимается как попытка переобъявления ранее объявленной переменной.

Эту самую пару операторов for можно переписать, например, следующим образом:

for (int i = 0, int j = 0; i < 100; i++, j--) < // Здесь располагаются операторы первого цикла. >for (i = 0, int k = 250; i < 100; i++, k--) < // Здесь располагаются операторы второго цикла. >

Здесь нет ошибок, но при чтении программы может потребоваться дополнительное время для того, чтобы понять, откуда берётся имя для выражения присвоения i = 0 во втором операторе цикла. Кроме того, если предположить, что операторы цикла в данном контексте реализуют независимые шаги какого-либо алгоритма, то почему попытка перемены мест пары абсолютно независимых операторов сопровождается сообщением об ошибке:

for (i = 0, int k = 250; i < 100; i++, k--) < // Здесь располагаются операторы второго цикла. >for (int i = 0, int j = 0; i < 100; i++, j--) < // Здесь располагаются операторы первого цикла. >

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

int i, j, k; . for (i = 0, k = 250; i < 100; i++, k--) < // Здесь располагаются операторы второго цикла. >for (i = 0, j = 0; i < 100; i++, j--) < // Здесь располагаются операторы первого цикла. >

А вот ещё один довольно странный оператор цикла, в котором, тем не менее, абсолютно корректно соблюдены принципы областей действия имён, областей видимости имён, а также соглашения о соотнесении имён и областей их действия:

for (int x; x

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

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

int XXX = 0; do while (XXX < 0);