Операторы break и continue в Pascal. Прерывание циклов

Создано: 11.04.2026

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

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

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

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

var i, n: integer;
begin
    readln(n);

    for i:=2 to n div 2 do
        if n mod i = 0 then
            write(i, ' ');

    writeln;    
end.

255
3 5 15 17 51 85

Ключевая составляющая ее алгоритма подходит и для тестирования числа на простоту. Действительно, если какое-либо число делится на любой делитель от 2 и далее, то оно составное, простым быть уже не может. Но если мы просто заменим в цикле write(i, ' ') на writeln('Число составное'), то получим на экране множество сообщений, если делитель у числа далеко не один.

Конечно, надо немного переписать код. И способов это сделать несколько. Например, можно посчитать делители, и если их окажется больше нуля, то число составное, иначе — простое:

var i, n, q: integer;
begin
    readln(n);
    q := 0;

    for i:=2 to n div 2 do
        if n mod i = 0 then
            q := q + 1;

    if q = 0 then
        writeln('Число простое')
    else
        writeln('Число составное');
end.

Также можно вместо цикла for использовать while, составив сложное условие его выполнения, в котором будет "флаговая переменная". Если "флажок был поднят", значит число составное.

var i, n, f: integer;
begin
    readln(n);
    f := 0; 

    i := 2;
    while (i < n div 2) and (f = 0) do begin
        if n mod i = 0 then
            f := 1;
        i := i + 1; 
    end;       

    if f = 0 then
        writeln('Число простое')
    else
        writeln('Число составное');
end.

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

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

var i, n, f: integer;
begin
    readln(n);
    f := 0;

    for i:=2 to n div 2 do
        if n mod i = 0 then begin
            f := 1;
            break;
        end;

    if f = 0 then
        writeln('Число простое')
    else
        writeln('Число составное');
end.

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

Упростите код выше так, чтобы на экране появлялось сообщение, только если число составное. "Молчание экрана" будет считаться признанием простоты числа. Нужда ли будет переменная f?

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

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

var i, n, f: integer;
begin
    readln(n);
    while n >= 2 do begin
        f := 0;
        for i:=2 to n div 2 do
            if n mod i = 0 then begin
                f := 1;
                break;
            end;   
        if f = 0 then
            writeln('- это простое.')
        else
            writeln('- это составное.');
        readln(n);  // следующее число
    end;
end.

108
- это составное.
73  
- это простое.
27
- это составное.
0

Здесь оператор break прерывает работу внутреннего цикла for, но не внешнего while. Поэтому мы можем вводить все новые и новые числа.

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

var i, n, f: integer;
begin
    while True do begin
        readln(n);
        f := 0;  // предполагаем, что число простое
        for i:=2 to n div 2 do
            if n mod i = 0 then begin
                f := 1;  // нет, оно составное
                break;
            end;   
        if f = 0 then begin
            writeln('Последнее число простое.');
            break;
        end;
    end;
end.

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

56
442
21
89
Последнее число простое.

Подумайте, каким должно было быть условие при while, если бы мы не знали про True? Какие еще изменения потребовалось бы внести в код?

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

В отличие от break оператор continue прерывает только текущее повторение (итерацию) тела цикла. Другими словами, если срабатывает continue, то код ниже его в теле цикла не исполняется, а поток выполнения сразу возвращается к заголовку цикла. Рассмотрим программу, которая суммирует только положительные числа из пяти вводимых:

var
    num, sum: real;
    i: integer;

begin
    sum := 0;
    write('Введите пять чисел: ');

    for i := 1 to 5 do begin
        read(num);
        if num <= 0 then
            continue;
        sum := sum + num
    end;

    writeln('Сумма положительных: ', sum:5:2);
end.

Введите пять чисел: 1.2 -3 2.3 -4.25 0
Сумма положительных:  3.50

До выражения sum := sum + num поток выполнения доходит только тогда, когда не заходит в тело if и не встречает там continue. Благодаря этому мы можем не помещать вычисление суммы в else. С другой стороны, при такой краткой реализации программы достаточно поменять условие при if на обратное, чтобы поместить в его тело вычисление суммы, и необходимости в continue не будет. Отсюда мы можем сделать вывод, что если уж без break при желании можно обойтись, то без continue подавно.

Измените программу с continue так, чтобы пользователю после каждого ввода числа сообщалось, было оно добавлено к сумме или нет. Больше ли тут пользы от continue? Почему?

Задания для дополнительной или самостоятельной работы:

Придумайте программу с циклом, в теле которого в одной ветке условного оператора используется процедура break, а в другой — continue.