Циклы в паскале

Еще примеры циклов for

Давайте, используя цикл for, напишем функцию вычисления значений в степени :

int pow(int base, int exponent)
{
int total = 1;

for (int count=0; count < exponent; ++count)
total *= base;

return total;
}

1
2
3
4
5
6
7
8
9

intpow(intbase,intexponent)

{

inttotal=1;

for(intcount=;count<exponent;++count)

total *=base;

returntotal;

}

Функция возвращает значение (число в степени ). — это число, которое нужно возвести в степень, а — это степень, в которую нужно возвести .

Если экспонент равен , то цикл for выполняется 0 раз, и функция возвращает .

Если экспонент равен , то цикл for выполняется 1 раз, и функция возвращает .

Если экспонент равен , то цикл for выполняется 2 раза, и функция возвращает .

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

#include <iostream>

int main()
{
for (int count = 8; count >= 0; —count)
std::cout << count << » «;

return 0;
}

1
2
3
4
5
6
7
8
9

#include <iostream>

intmain()

{

for(intcount=8;count>=;—count)

std::cout<<count<<» «;

return;

}

Результат:

Также с каждой новой итерацией мы можем увеличить или уменьшить значение счетчика больше, чем на единицу:

#include <iostream>

int main()
{
for (int count = 9; count >= 0; count -= 2)
std::cout << count << » «;

return 0;
}

1
2
3
4
5
6
7
8
9

#include <iostream>

intmain()

{

for(intcount=9;count>=;count-=2)

std::cout<<count<<» «;

return;

}

Результат:

Неформальный пример

Следующая подпрограмма C возвращает максимальное значение в своем массиве аргументов при условии, что его длина не менее 1. Комментарии предоставляются в строках 3, 6, 9, 11 и 13. Каждый комментарий содержит утверждение о значениях одной или нескольких переменных. на этом этапе функции. Выделенные утверждения в теле цикла в начале и в конце цикла (строки 6 и 11) абсолютно одинаковы. Таким образом, они описывают инвариантное свойство цикла. Когда достигается строка 13, этот инвариант все еще сохраняется, и известно, что условие цикла из строки 5 стало ложным. Оба свойства вместе означают, что оно равно максимальному значению в , то есть правильное значение возвращается из строки 14.

int max(int n, const int a[]) {
    int m = a];
    // m equals the maximum value in a
    int i = 1;
    while (i != n) {
        // m equals the maximum value in a
        if (m < ai])
            m = ai];
        // m equals the maximum value in a
        ++i;
        // m equals the maximum value in a
    }
    // m equals the maximum value in a, and i==n
    return m;
}

Следуя парадигме защитного программирования , условие цикла в строке 5 лучше изменить на , чтобы избежать бесконечного цикла для недопустимых отрицательных значений . Хотя это изменение в коде интуитивно не должно иметь никакого значения, рассуждения, ведущие к его правильности, становятся несколько более сложными, поскольку тогда известно только в строке 13. Чтобы получить это также , это условие должно быть включено в цикл. инвариантный. Легко видеть, что это также является инвариантом цикла, поскольку в строке 6 может быть получено из (модифицированного) условия цикла в строке 5 и, следовательно, выполняется в строке 11 после увеличения в строке 10. Однако, когда инварианты цикла должны быть предоставлены вручную для формальной проверки программы, такие интуитивно слишком очевидные свойства, как часто игнорируются.

Поддержка языков программирования

Эйфель

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

    из        Икс :=     инвариантный        Икс <= 10    до того как        Икс > 10    петля        Икс := Икс + 1    конец

Пока

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

функция Максимум(int[] Предметы) -> (int р)// Требуется хотя бы один элемент для вычисления макс.требует |Предметы| > // (1) Результат не меньше любого элементаобеспечивает все { я в ..|Предметы| | Предметыя <= р }// (2) Результат соответствует хотя бы одному элементуобеспечивает немного { я в ..|Предметы| | Предметыя == р }    //    нац я = 1    int м = Предметы    //    пока я < |Предметы|    // (1) Ни один из видимых на данный момент элементов не превышает m    куда все { k в ..я | Предметыk <= м }    // (2) Один или несколько видимых до сих пор элементов соответствует m    куда немного { k в ..я | Предметыk == м }        если Предметыя > м            м = Предметыя        я = я + 1    //    возвращаться м

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

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

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

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

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

Решение:

program cycle2;
var n,kinteger; { n - заданное целое, k - искомое число}
begin
read(n); { ввод значения числа N }
 repeat
   k=k+1; { вычисление проверяемого числа }
 until k*k > n; { проверка найденного числа на соответствие условию завершения цикла}
write(k); { вывод найденного числа }
end.

Решение:

var a,c1,c2int64;
begin
 write('Введите исходное число => ');
 readln(a);
 c1=a mod 10;
 if a>9 then  
    while a> do
    begin
      c2=a;
      a=a div 10;
    end;
 write('Сумма первой и последней цифры = ',c1+c2);
end.

Неформальный пример

int max(int n, const int a[]) {
    int m = a];
    // m equals the maximum value in a
    int i = 1;
    while (i != n) {
        // m equals the maximum value in a
        if (m < ai])
            m = ai];
        // m equals the maximum value in a
        ++i;
        // m equals the maximum value in a
    }
    // m equals the maximum value in a, and i==n
    return m;
}

Операторы условий

Оператор if

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

формируется следующим образом:

int x = 56;

bool check_x()
{
    if (x > 0)
        return true;
    return false;
}

В данном случае условие помещено в скобках после оператора if. В данной конструкции код

return true;

будет выполняться в том случае, если x будет больше 0. следующая строка

return false;

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

Первый вариант:

int x = 56;

bool check_x()
{
    if (x > 0)
        x = 0;
        return true;
    return false;
}

В данном коде

return true;

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

x = 0;

Второй вариант:

int x = 56;

bool check_x()
{
    if (x > 0)
    {
        x = 0;
        return true;
    }
    return false;
}

В данном коде

return true;

будет выполняться только при выполнении условия

x > 0

Оператор else

Оператор

else

используется совместно с оператором

для формирования последовательности условий.

int x = 56;

bool check_x()
{
    if (x > 0)
    {
        x = 0;
        return true;
    }
    else if (x < 0)
    {
        x = 0;
        return false;
    }
    else
    {
        return false;
    }
}

Оператор else может использоваться как для добавления нового условия, если не выполнилось предыдущее условие — конструкция

else if.

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

Операторы switch, case, break, default

Конструкция

switch case

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

switch case

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

int x = 100;

bool check_x()
{
    switch (x)  
    {
        case 0:
            return true;
        case 50:
            x = 0:
            break;
        case 100:
            return false;
        default:
            return false;
    }

В выше представленном коде переменная x проверяется на равенство числам 0, 50, 100. Оператор

default

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

case 50:

добавлен оператор

break

, этот оператор выполняет выход из условия, тогда как оператор return выполняет выход из функции. Если не добавлять оператор break, то выполнение кода продолжится и в блоке

case 100: .

Благодаря этой особенности конструкции

switch case

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

int x = 100;

bool check_x()
{
    switch (x)  
    {
        case 0:
        case 50:
        case 100:
            return true;
        default:
            return false;
    }
}

Таким образом для x равного 0, 50, 100 функция вернёт true, тогда как для всех остальных значений функция будет возвращать false.

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

int x = 100;

int check_x()
{
    switch (x)  
    {
        case 0:
        {
            int y = 1;
            return y;
        }
        case 50:
        {
            int y = 2;
            return y;
        }
        case 100:
        {
            int y = 3;
            return y;
        }
        default:
            return x;
    }
}

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

Задачи на циклы Паскаль

Решение:Вариант 1

program cycle1;
var a,breal; {a,b - вещественные числа }
begin
  read(a,b); { ввод исходных значений длин отрезков }
    while a > b do a=a-b; { цикл - вычисление остатка отрезка А }
  write(a); { вывод остатка отрезка А }
end.

Вариант 2 (с подсказками)

program cycle1;
var a,breal;
begin
  write('Введите длину отрезка А '); { вывод текстовой подсказки на экран }
  readln(a); { ввод исходного значения длины отрезка А }
  write('Введите длину отрезка В '); { вывод текстовой подсказки на экран }
  readln(b); { ввод исходного значения длины отрезка В }
    while a > b do a=a-b; { цикл - вычисление остатка отрезка А }
  write('Длина незанятой части отрезка А равна ',a); { вывод остатка отрезка А }
end.

Решение для 1 ряда:

var a,ap,sreal;{а - текущий элемент, ар - предыдущий элемент}
   iinteger;{счетчик элементов ряда}
begin
   s=;{первоначальная сумма}
   i=1;{начинаем ряд с первого элемента}
   a=;{ это значение нужно для запуска цикла}
   ap=1;{это значение нужно для запуска цикла}
while Abs(a-ap)>1e-6 do {модуль разницы между соседними должен быть больше заданной точности для работы цикла}
 begin
   ap=a;{запоминаем предыдущий элемент}
   a=1(i*i*2);{вычисляем текущий элемент}
   s=s+a;{считаем сумму}
   i=i+1;{переходим к следующему}
 end;
write('Сумма ряда = ',s);{вывод результата}
end.

Формула текущего элемента для второго ряда a:=1/(i*(i+1)*(i+2)); для третьего — a:=1/(i*(i+2));

Объявления переменных в цикле for

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

#include <iostream>

int main()
{
int aaa, bbb;
for (aaa = 0, bbb = 9; aaa < 10; ++aaa, —bbb)
std::cout << aaa << » » << bbb << std::endl;

return 0;
}

1
2
3
4
5
6
7
8
9
10

#include <iostream>

intmain()

{

intaaa,bbb;

for(aaa=,bbb=9;aaa<10;++aaa,—bbb)

std::cout<<aaa<<» «<<bbb<<std::endl;

return;

}

Этот цикл присваивает значения двум ранее объявленным переменным: и . Только с каждой итерацией переменная увеличивается на единицу, а — уменьшается на единицу.

Результат выполнения программы:

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

#include <iostream>

int main()
{
for (int aaa = 0, bbb = 9; aaa < 10; ++aaa, —bbb)
std::cout << aaa << » » << bbb << std::endl;

return 0;
}

1
2
3
4
5
6
7
8
9

#include <iostream>

intmain()

{

for(intaaa=,bbb=9;aaa<10;++aaa,—bbb)

std::cout<<aaa<<» «<<bbb<<std::endl;

return;

}

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

Спецификация оператора for/in/else:

for_stmt :: = "for" target_list "in" expression_list ":" suite
              "else" ":" suite

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

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

Применим оператор и в коде и посмотрим на их поведение. Будем создавать список четных чисел из последовательности чисел от 0 до 14.

lst = []
for item in range(15) 
    # если число 10 есть в списке
    if 10 in lst
        # прерываем цикл, при этом блок else не выполнится
        break
    # остаток от деления элемента списка
    a = item % 2
    # если элемент списка не четный или равен 0
    if a !=  or item == 
        # пропускаем оставшийся код
        continue
    # добавление числа в список
    lst.append(item)
else
    print ("Напечатает, если убрать условие с break")

print(lst)
# Код выведет:
2, 4, 6, 8, 10

Цикл выполняет назначения переменным в целевом списке. Это перезаписывает все предыдущие назначения этим переменным, включая те, которые были сделаны в блоке :

Пример:

for i in range(10):
    print(i)
    i = 5
    # это не повлияет на цикл for так как переменная i
    # будет перезаписана следующим итерируемым элементом

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

Подсказка: встроенная функция возвращает итератор целых чисел, подходящий для эмуляции эффекта языка Pascal например, возвращает список .

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

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

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

b = a
for item in b
    if item <  
        a.remove(item)

Цикл for

Этот блок покажет вам, как выполнить определенную итерацию с циклом Python .

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

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

Вот что вы узнаете в этом блоке:

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

Логика Флойда – Хора [ править ]

В Флойда-Хоара логики , частичная корректность из время цикла регулируется с помощью следующего правила вывода:

{C∧я}боdy{я}{я}шчасяле (C) боdy{¬C∧я}{\ displaystyle {\ frac {\ {C \ land I \} \; \ mathrm {body} \; \ {I \}} {\ {I \} \; \ mathbf {while} \ (C) \ mathrm {body} \; \ {\ lnot C \ land I \}}}}

Это означает:

Если какое-то свойство сохраняется в коде — точнее, если сохраняется после выполнения каждого из них и удерживается заранее — (верхняя строка), тоя{\ displaystyle I}боdy{\ displaystyle \ mathrm {body}}я{\ displaystyle I}боdy{\ displaystyle \ mathrm {body}}C{\ displaystyle C}я{\ displaystyle I}
C{\ displaystyle C}и гарантированно будут ложными и истинными, соответственно, после выполнения всего цикла , при условии, что до цикла было истинно (нижняя строка) .я{\ displaystyle I}шчасяле (C) боdy{\ displaystyle \ mathbf {while} \ (C) \ \ mathrm {body}}я{\ displaystyle I}

Другими словами: приведенное выше правило — дедуктивный шаг, в основе которого лежит тройка Хоара . Эта тройка на самом деле является отношением состояний машины. Он сохраняется всякий раз, когда, начиная с состояния, в котором логическое выражение истинно, и при успешном выполнении некоторого вызванного кода , машина оказывается в состоянии, в котором истинно. Если это отношение может быть доказано, правило позволяет нам сделать вывод, что успешное выполнение программы приведет к переходу из состояния, в котором верно, в состояние, в котором выполняется. Логическая формула в этом правиле называется инвариантом цикла.{C∧я}боdy{я}{\ Displaystyle \ {С \ земля I \} \; \ mathrm {body} \; \ {I \}}C∧я{\ displaystyle C \ land I}боdy{\ displaystyle \ mathrm {body}}я{\ displaystyle I}шчасяле (C) боdy{\ displaystyle \ mathbf {while} \ (C) \ \ mathrm {body}}я{\ displaystyle I}¬C∧я{\ displaystyle \ lnot C \ land I}я{\ displaystyle I}

Пример

В следующем примере показано, как работает это правило. Рассмотрим программу

в то время как (x <10)

Тогда можно доказать следующую тройку Хоара:

{Икс≤10}шчасяле (Икс<10) Иксзнак равноИкс+1{Иксзнак равно10}{\ Displaystyle \ {х \ Leq 10 \} \; \ mathbf {while} \ (х <10) \ х: = х + 1 \; \ {х = 10 \}}

Условие С из петли . Необходимо угадать полезный инвариант цикла ; окажется, что это уместно. При этих предположениях можно доказать следующую тройку Хоара:Икс<10{\ displaystyle x <10}я{\ displaystyle I}Икс≤10{\ Displaystyle х \ leq 10}

{Икс<10∧Икс≤10}Иксзнак равноИкс+1{Икс≤10}{\ Displaystyle \ {х <10 \ земля х \ leq 10 \} \; х: = х + 1 \; \ {х \ leq 10 \}}

Хотя эта тройка формально может быть получена из правил логики Флойда-Хоара, регулирующих присваивание, она также интуитивно оправдана: вычисление начинается в состоянии, где истинно, что означает просто, что это правда. Вычисление прибавляет 1 к , что означает, что это все еще верно (для целого числа x).Икс<10∧Икс≤10{\ Displaystyle х <10 \ земля х \ leq 10}Икс<10{\ displaystyle x <10}Икс{\ displaystyle x}Икс≤10{\ Displaystyle х \ leq 10}

Исходя из этой предпосылки, правило петель позволяет сделать следующий вывод:

{Икс≤10}шчасяле (Икс<10) Иксзнак равноИкс+1{¬(Икс<10)∧Икс≤10}{\displaystyle \{x\leq 10\}\;\mathbf {while} \ (x<10)\ x:=x+1\;\{\lnot (x<10)\land x\leq 10\}}

Однако постусловие ( меньше или равно 10, но не меньше 10) логически эквивалентно тому , что мы хотели показать.¬(x<10)∧x≤10{\displaystyle \lnot (x<10)\land x\leq 10}x{\displaystyle x}x=10{\displaystyle x=10}

Свойство — это еще один инвариант цикла примера, а тривиальное свойство — еще одно. Применение приведенного выше правила вывода к предыдущим инвариантным доходам . Применяя его к инвариантной доходности , что немного более выразительно.≤x{\displaystyle 0\leq x}true{\displaystyle \mathrm {true} }{≤x}while (x<10) x:=x+1{10≤x}{\displaystyle \{0\leq x\}\;\mathbf {while} \ (x<10)\ x:=x+1\;\{10\leq x\}}true{\displaystyle \mathrm {true} }{true}while (x<10) x:=x+1{10≤x}{\displaystyle \{\mathrm {true} \}\;\mathbf {while} \ (x<10)\ x:=x+1\;\{10\leq x\}}

Цикл while в Python

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

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

Синтаксис приведен ниже.

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

Операторы управления циклом

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

1. Оператор continue — Когда встречается оператор , управление переходит в начало цикла. Давайте разберем следующий пример.

Вывод:

2. Оператор break — Когда встречается оператор , он выводит управление из цикла.

Пример:

Вывод:

3. Оператор pass — Оператор используется для объявления пустого цикла. Он также используется для определения пустого класса, функции и оператора управления. Давайте разберем следующий пример.

Вывод

Пример 1: Программа для печати от 1 до 10 с использованием цикла while

Вывод

Пример 2: Программа для печати таблицы заданных чисел.

Вывод

Бесконечный цикл while

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

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

Пример 1

Вывод

Пример 2

Вывод

Использование else в цикле while

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

Вывод

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

Программа для печати чисел Фибоначчи до заданного предела

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

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

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

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

Вот примеры кода:

В этом фрагменте был создан двумерный массив chars, по которому мы прошли с помощью одного цикла for, вложенного в другой — тоже for. Для каждой итерации внешнего цикла выполняются все итерации вложенного в него внутреннего. Таким образом, для массива размерности 5 на 5 будет совершено 25 итераций — внешний цикл идёт по строкам, внутренний — по столбцам.

Ещё пример, но теперь уже трёх вложенных циклов:

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

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

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

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

while true или бесконечный цикл

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

Однако вы некоторых случая бесконечный цикл делают намерено:

Если нужно производить какие-то действия с интервалом, и выходить из цикла лишь в том случае, когда внутри тела «зашито» условие выхода.
Пример: функция, которая возвращает базы данных. Если связь с базой данных отсутствует, соединение будет пытаться (в цикле) установиться до тех пор, пока не установится.
Если вы пишете полноценный демон, который продолжительное время висит как процесс в системе и периодически производит какие-то действия. В таком случае остановкой цикла будет прерывание работы программы. Пример: скрипт, который раз в 10 минут «пингует» IP адреса и пишет в лог отчет о доступности этих адресов.

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

Код был прерван комбинацией клавиш + . Иначе цикл продолжался бы бесконечно.