$ sudo teach IT
Модуль 4 · Цикл while

Урок 4.2 — Break, continue, return

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

Циклы работают по принципу «повторяй, пока условие истинно». Но в реальных задачах часто нужно вмешаться в этот процесс: досрочно выйти из цикла, пропустить одну итерацию или вообще завершить весь метод. Для этого в C# есть три оператора: break, continue и return.

🚪

Оператор break — немедленный выход из цикла

break мгновенно завершает текущий цикл. Программа продолжает выполнение с первой строки после цикла. break работает с любым циклом: while, for, foreach (и даже с switch, как мы видели).

C# · Break в действии
// Поиск первого чётного числа в диапазоне
int i = 1;
while (i <= 10)
{
    Console.WriteLine($"Проверяем: {i}");

    if (i % 2 == 0)
    {
        Console.WriteLine($"Нашли чётное: {i}");
        break;  // ← выход из цикла
    }

    i++;
}
// Вывод:
// Проверяем: 1
// Проверяем: 2
// Нашли чётное: 2
// Цикл завершён! i больше не увеличивается, программа идёт дальше

break часто используется в while (true) — это стандартный паттерн «цикл с выходом посередине»:

C# · Паттерн «цикл с выходом посередине»
while (true)
{
    Console.Write("Введите положительное число: ");
    string input = Console.ReadLine();

    if (!int.TryParse(input, out int number))
    {
        Console.WriteLine("Ошибка! Введите число.");
        continue;  // пропускаем — начинаем новую итерацию
    }

    if (number <= 0)
    {
        Console.WriteLine("Число должно быть положительным!");
        continue;
    }

    // Если дошли сюда — всё хорошо
    Console.WriteLine($"Вы ввели: {number}");
    break;  // выход из цикла
}
Console.WriteLine("Спасибо за корректный ввод!");
💡 Этот паттерн очень популярен. Вместо того чтобы писать сложное условие в while, мы делаем while (true) и сами решаем когда выходить. Это делает код линейным и понятным.
⏭️

Оператор continue — пропуск итерации

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

C# · Continue — пропуск нечётных
// Выводим только чётные числа от 1 до 10
int n = 0;
while (n < 10)
{
    n++;
    if (n % 2 != 0)
    {
        continue;  // пропускаем нечётные
    }
    Console.Write(n + " ");  // выполняется только для чётных
}
// Вывод: 2 4 6 8 10

Ещё пример — пропуск «плохих» данных при обработке:

C# · Фильтрация данных
// Обработка температур: игнорируем некорректные
int count = 0;
double sum = 0;

while (count < 5)
{
    Console.Write($"Введите температуру #{count + 1}: ");
    string input = Console.ReadLine();

    if (!double.TryParse(input, out double temp))
    {
        Console.WriteLine("Некорректное значение, попробуйте ещё раз.");
        continue;  // не увеличиваем count — пробуем снова
    }

    if (temp < -100 || temp > 100)
    {
        Console.WriteLine("Температура вне диапазона, пропускаем.");
        continue;  // увеличиваем count, но не суммируем
    }

    sum += temp;
    count++;
}

Console.WriteLine($"Средняя температура: {sum / 5:F1}");
💡 Обрати внимание: в первом continue мы не увеличиваем count (пользователь ввёл не число — даём ещё попытку). А во втором continue мы уже увеличили count, но не суммируем. Два continue с разной логикой!
📊

Сравнение break и continue

Оператор
Действие
Когда использовать
break
Полностью выходит из цикла
Нашли искомое, достигли условия выхода
continue
Пропускает только текущую итерацию
Нужно пропустить «плохие» данные, но продолжать цикл
return
Выходит из всего метода
Больше нет смысла продолжать метод вообще

✅ break — досрочный выход

// Ищем число 7
int[] nums = {1, 3, 7, 9};
int i = 0;
while (i < nums.Length)
{
    if (nums[i] == 7)
    {
        Console.WriteLine("Нашли 7!");
        break;  // выходим
    }
    i++;
}
Console.WriteLine("После цикла");

✅ continue — пропуск

// Сумма только чётных
int sum = 0;
int n = 0;
while (n < 10)
{
    n++;
    if (n % 2 != 0)
        continue;
    sum += n;
}
Console.WriteLine(sum);  // 30
🔙

Оператор return — выход из метода

return завершает весь метод, а не только цикл. Если метод что-то возвращает (не void), после return нужно указать возвращаемое значение.

C# · Return в цикле
static int FindFirstEven(int[] numbers)
{
    int i = 0;
    while (i < numbers.Length)
    {
        if (numbers[i] % 2 == 0)
        {
            return numbers[i];  // нашли → выходим из метода
        }
        i++;
    }
    return -1;  // если чётных нет
}

int[] arr = { 3, 7, 2, 9, 4 };
Console.WriteLine(FindFirstEven(arr));  // 2

⚠️ return из цикла — самый «жёсткий» способ прерывания. Он не просто выходит из цикла, а завершает весь метод. Помни об этом: после return ни одна строка метода не выполнится.

Сравни break и return на примере:

C# · Break vs Return
static void BreakExample()
{
    int i = 0;
    while (i < 5)
    {
        if (i == 2)
        {
            Console.WriteLine("Break!");
            break;
        }
        i++;
    }
    Console.WriteLine("После break — это выполнится!");
}
// Вывод:
// Break!
// После break — это выполнится!

static void ReturnExample()
{
    int i = 0;
    while (i < 5)
    {
        if (i == 2)
        {
            Console.WriteLine("Return!");
            return;
        }
        i++;
    }
    Console.WriteLine("После return — это НЕ выполнится!");
}
// Вывод:
// Return!
🛠️

Практика: поиск числа и валидация ввода

Объединим знания в реальных сценариях.

C# · Поиск простого числа
// Проверка: является ли число простым?
static bool IsPrime(int n)
{
    if (n < 2) return false;

    int divisor = 2;
    while (divisor <= Math.Sqrt(n))
    {
        if (n % divisor == 0)
            return false;  // нашли делитель — не простое
        divisor++;
    }
    return true;  // делителей нет — простое
}

Console.WriteLine(IsPrime(17));  // True
Console.WriteLine(IsPrime(25));  // False

💡 Функция проверки простоты числа — классический пример использования return в цикле. Как только нашли делитель — сразу false. Если весь цикл прошли, а делителя нет — true. Math.Sqrt(n) — оптимизация: если у числа есть делитель, один из них не больше квадратного корня.

C# · Валидация ввода через while (true)
using System;

class Program
{
    static void Main()
    {
        // Запрашиваем возраст с валидацией
        int age = GetValidAge();
        Console.WriteLine($"Ваш возраст: {age}");
    }

    static int GetValidAge()
    {
        while (true)
        {
            Console.Write("Введите ваш возраст (1-120): ");
            string input = Console.ReadLine();

            if (!int.TryParse(input, out int age))
            {
                Console.WriteLine("Ошибка: введите число!");
                continue;
            }

            if (age < 1 || age > 120)
            {
                Console.WriteLine("Ошибка: возраст от 1 до 120!");
                continue;
            }

            return age;  // всё корректно — возвращаем
        }
    }
}
💡 Метод GetValidAge() будет запрашивать возраст бесконечно, пока пользователь не введёт корректное значение. Как только ввод верен — return age завершает и цикл, и метод. Очень удобный паттерн!
🧪

Мини-тест

Проверь понимание break, continue, return.

Вопрос 1

int i = 1;
int sum = 0;
while (i <= 5)
{
    if (i == 3)
    {
        i++;
        continue;
    }
    sum += i;
    i++;
}
Console.WriteLine(sum);

Варианты: A) 12   B) 15   C) 10

Вопрос 2

int x = 10;
while (x > 0)
{
    if (x < 5) break;
    x -= 3;
}
Console.WriteLine(x);

Варианты: A) 10   B) 4   C) 1

Вопрос 3

static int Test()
{
    int i = 0;
    while (i < 3)
    {
        i++;
        if (i == 2) return i;
    }
    return -1;
}
Console.WriteLine(Test());

Варианты: A) 1   B) 2   C) -1

Вопрос 4

int n = 0;
while (n < 5)
{
    n++;
    if (n == 3) continue;
    if (n == 4) break;
    Console.Write(n + " ");
}

Варианты: A) 1 2   B) 1 2 4   C) 1 2 3

💡 Ответы: 1 — A (i=3 пропускается: 1+2+4+5=12). 2 — B (10→7→4, на 4 x<5 → break). 3 — B (на i=2 return 2). 4 — A (n=1 печать, n=2 печать, n=3 continue, n=4 break).
🎮

Задача

Задание: Сумма положительных чисел

Напиши программу, которая:

  1. Запрашивает у пользователя целые числа (по одному)
  2. Суммирует только положительные числа
  3. Пропускает отрицательные (continue)
  4. Завершает ввод, когда пользователь вводит 0 (break)
  5. После ввода 0 выводит сумму

Пример работы:

Введите число: 10
Введите число: -5
Введите число: 7
Введите число: -3
Введите число: 0
Сумма положительных чисел: 17

Дополнительно: используй TryParse для защиты от некорректного ввода. Если пользователь ввёл не число — выведи сообщение и не засчитывай попытку.

💡 Это задача на комбинирование break и continue. while (true) с break при вводе 0, continue для отрицательных чисел и для некорректного ввода.
📌

Что важно запомнить

1️⃣
break — немедленно выходит из цикла. Используется для досрочного завершения.
2️⃣
continue — пропускает оставшуюся часть итерации и переходит к следующей. Цикл продолжается.
3️⃣
return — завершает весь метод, не только цикл. Самый «жёсткий» способ прерывания.
4️⃣
while (true) + break — популярный паттерн «цикл с выходом посередине». Удобен для валидации ввода.
5️⃣
break и continue работают только с ближайшим (самым внутренним) циклом. Для внешних циклов нужны другие подходы.

Тест: 4.2: Break, continue, return

5 вопросов

Сумма чисел

Premium