Лекция №3. Управление потоком. Условные операторы и Циклы.
§3.1 Условные операторы
Условные операторы являются фундаментальным элементом управления потоком выполнения программы. Они позволяют принимать решения на основе истинности или ложности заданных условий, обеспечивая ветвление алгоритма — выбор одного из нескольких возможных путей выполнения в зависимости от текущего состояния данных.
Условные операторы применяются для реализации логики, при которой определённые блоки кода должны выполняться только при соблюдении конкретных критериев. Это делает программы динамичными и адаптивными к различным входным данным и условиям среды.
В языках C# и C++ предусмотрены различные формы условных конструкций, каждая из которых предназначена для определённых сценариев. К ним относятся: оператор условного ветвления if / else, оператор множественного выбора switch / case, тернарный условный оператор и оператор безусловного перехода goto. Эти средства позволяют гибко управлять ходом выполнения программы, обеспечивая как простые, так и сложные логические структуры.
§3.1.1 Операторы условного ветвления if / else
Одним из наиболее распространённых и универсальных средств управления потоком выполнения программы является оператор условного ветвления if / else. Он позволяет программе принимать решения на основе проверки логического условия: если условие истинно, выполняется один блок кода, если ложно — другой (или не выполняется вовсе).
Синтаксически оператор if представляет собой конструкцию, в которой после ключевого слова if в круглых скобках указывается выражение, интерпретируемое как логическое значение (истина или ложь). Если это выражение истинно (в C++ — ненулевое значение, в C# — значение типа bool, равное true), то выполняется соответствующий блок кода, заключённый в фигурные скобки (или один оператор, если скобки опущены). При невыполнении условия можно указать альтернативный блок кода с помощью ключевого слова else.
Синтаксис конструкции в языке C# и С++ одинаков:
text
if (условное выражение)
{
//Сделать нечто, когда условное выражение true;
}
else
{
//Сделать другое, когда условное выражение false;
}
Часть else конструкции if … else является необязательной и может не использоваться в тех ситуациях, когда в противном случае не нужно делать ничего.
Конструкция допускает каскадное ветвление: с помощью цепочки if – else if – else можно проверять несколько взаимоисключающих условий последовательно. Это особенно полезно при реализации множественного выбора, когда необходимо выбрать один из нескольких возможных путей выполнения.
Проанализируем конструкцию в листинге ниже, обрабатывающую условное выражение и позволяющую пользователю решить, следует ли умножить или просуммировать два числа.
csharp
using System;
class Program
{
static void Main()
{
Console.WriteLine("Введите два числа:");
int num1 = int.Parse(Console.ReadLine());
int num2 = int.Parse(Console.ReadLine());
Console.Write("Введите m для умножения: ");
char userSelection = Console.ReadKey();
int result = 0;
if (userSelection == 'm')
{
result = num1 * num2;
}
else
{
result = num1 + num2;
}
Console.WriteLine($"Результат: {result}");
}
}
Результат выполнения программы:
text
Введите два числа:
25
56
Введите m для умножения: m
Результат: 1400
следующий запуск:
text
Введите два числа:
25
56
Введите m для умножения: a
Результат: 81
Обратите внимание на использование оператора if в строке 13 и оператора else в строке 15. В строке 13 мы инструктируем компилятор выполнить умножение, если следующее за оператором if выражение (UserSelection == 'm') истинно (возвращает значение true), или выполнять сложение, если выражение ложно 3 (возвращает значение false).
Выражение (UserSelection == 'm') возвращает значение true, когда пользователь вводит символ (с учетом регистра), и значение false в любом другом случае.
Таким образом, эта простая программа моделирует блок – схему и демонстрирует, как ваше приложение может вести себя по-другому при иной ситуации:
Нередки ситуации, когда необходимо проверить несколько разных условий, некоторые из которых зависят от результата оценки предыдущего условия. Разрешено вкладывать операторы if для выполнения таких требований. Вложенные операторы if имеют следующий синтаксис:
text
if (условие 1)
{
СделатьНечто 1;
if (условие2)
{
СделатьНечто2;
}
else
{
СделатьНечтоДругое2;
}
}
else
{
СделатьНечтоДругое1;
}
Например:
csharp
using System;
class Program
{
static void Main()
{
Console.Write("Введите возраст: ");
int age = int.Parse(Console.ReadLine());
Console.Write("Есть ли у вас водительские права: ");
char hasLicenseInput = Console.ReadKey().KeyChar;
if (age >= 18)
{
Console.WriteLine("Вы совершеннолетний.");
if (hasLicenseInput == 'y' ||
hasLicenseInput == 'Y')
{
Console.WriteLine("Водите на здоровье.");
}
else
{
Console.WriteLine("У вас нет прав :/");
}
}
else
{
Console.WriteLine("Вы несовершеннолетний!");
}
Console.WriteLine("Программа завершена.");
}
}
При разных сценариях данная программа выведет разные результаты, например:
text
Введите возраст: 20
Есть ли у вас водительские права: y
Вы совершеннолетний.
Водите на здоровье.
Программа завершена.
или
text
Введите возраст: 25
Есть ли у вас водительские права: n
Вы совершеннолетний.
У вас нет прав :/
Программа завершена.
§3.1.2 Оператор множественного выбора switch / case
Оператор switch
— это средство множественного ветвления, предназначенное для выбора одного из нескольких альтернативных путей выполнения программы на основе значения выражения.
В отличие от цепочки if – else if, которая последовательно проверяет условия, switch обеспечивает прямой переход к ветви, соответствующей конкретному значению, что делает его более эффективным и читаемым в случаях, когда требуется сравнение одного выражения с несколькими константами.
Оператор switch оценивает выражение (называемое управляющим выражением) и сравнивает его значение с метками case, каждая из которых представляет собой константное выражение. При совпадении управление передаётся на соответствующую ветвь. Если ни одно из значений case не совпадает, выполняется ветвь default (если она присутствует).
switch особенно удобен при обработке:
- Выбора из меню.
- Обработки кодов ошибок.
Синтаксис на С++ и С# практически идентичен:
switch (выражение) {
case значение1:
// код
break;
case значение2:
// код
break;
default:
// код по умолчанию
break;
}
При использовании switch … case следует учитывать особенности и ограничения:
1. Метки case должны быть уникальными и константными выражениями.
- Нельзя использовать переменные или диапазоны напрямую (например, case x: — ошибка).
2. Обязательность break (в C++ и C#).
- Отсутствие break приводит к проваливанию (fall-through) — выполнению кода следующей ветви case, что может быть опасной ошибкой.
- В C# явный fall-through запрещён, если только ветвь не пустая (но это требует явного указания и считается плохой практикой).
3. Наличие default — необязательно, но рекомендуется.
Пример использования конструкции switch … case:
csharp
Console.Write("Введите оценку (A, B, C, D, F): ");
char grade = Console.ReadKey().KeyChar;
Console.WriteLine();
switch (grade)
{
case 'A':
Console.WriteLine("Отлично!");
break;
case 'B':
Console.WriteLine("Хорошо.");
break;
case 'C':
Console.WriteLine("Удовлетворительно.");
break;
case 'D':
Console.WriteLine("Неудовлетворительно.");
break;
case 'F':
Console.WriteLine("Сдано.");
break;
default:
Console.WriteLine("Некорректная оценка.");
break;
}
Важно учитывать, что без break — после case 'A' выполнились бы все последующие ветви до default. default рекомендуется, потому что защищает от некорректного ввода.
§3.1.3 Условный тернарный оператор
Условный тернарный оператор (?:)
— это компактная форма ветвления, позволяющая выбрать одно из двух значений в зависимости от истинности логического условия.
Являясь единственным тернарным оператором в языках C++ и C#, он предоставляет удобный способ записи простых условных выражений без необходимости использования полноценной конструкции if / else.
Синтаксически оператор состоит из трёх операндов, откуда и происходит название «тернарный»:
text
condition ? expression_if_true : expression_if_false
- condition — логическое выражение, результат которого оценивается как true или false.
- expression_if_true — выражение, значение которого возвращается, если условие истинно.
- expression_if_false — выражение, возвращаемое при ложности условия.
Результатом всего выражения является значение одного из двух выражений, в зависимости от условия. Это именно выражение, а не оператор, что означает: оно возвращает значение и может использоваться в присваиваниях, возврате из функций, вызовах методов и других контекстах, где ожидается значение.
В стилистике if / else данный оператор можно записать в следующем виде:
text
if(логическое условное выражение)
{
выражение1 при true;
}
else
{
выражение2 при false;
}
Пример на языке C#:
csharp
int age = 20;
string status = age >= 18 ? "Совершеннолетний"
: "Несовершеннолетний";
Console.WriteLine(status); // Вывод: Совершеннолетний
Пример на языке C++:
cpp
#include <iostream>
using namespace std;
int main() {
int a = 5, b = 10;
int max = (a > b) ? a : b;
cout << "Максимум: " << max << endl; // Вывод: 10
return 0;
}
Важно понимать, что оба выражения (expression_if_true и expression_if_false) должны быть неявно приводимы к одному общему типу, иначе возникнет ошибка компиляции. Пример из C#:
csharp
// Допустимо: string и string
string result = condition ? "Yes" : "No";
// Допустимо: int и double → результат double
double value = flag ? 5 : 3.14;
// Опасно: object и int — будет object, но с boxing
object obj = flag ? "text" : 123;
В C# компилятор выводит общий тип на основе выражений. В C++ тип результата определяется по правилам стандартных преобразований (например, int и double → double).
в C++ при смешении знаковых и беззнаковых типов знаковый операнд может быть преобразован к беззнаковому, что может привести к неожиданному поведению.
Например, -50 как unsigned int станет очень большим положительным числом.
cpp
unsigned int u = 100;
signed int s = -50;
auto result = (u > s) ? u : s;
// Тип: unsigned int (внимание — здесь есть нюанс!)
§3.1.4 Оператор goto
Оператор goto
— это оператор безусловного перехода, позволяющий передать управление непосредственно на метку (обозначенное имя) внутри той же функции. Несмотря на свою простоту и мощь, goto считается одним из наиболее спорных и критикуемых инструментов в структурном программировании.
Синтаксис в C++ и C#:
goto label;
...
label: statement;
Оператор goto позволяет нарушить естественный порядок выполнения программы, перейдя к указанному участку кода. В теории он универсален — с его помощью можно реализовать любую управляющую структуру (циклы, ветвления), однако на практике его использование сильно ограничено из-за риска снижения читаемости и поддерживаемости кода.
Пример использования goto в С#:
csharp
using System;
class Program
{
static void Main()
{
Start:
Console.Write("Введите 'да' или 'нет': ");
string answer = Console.ReadLine();
if (answer == "да")
{
Console.WriteLine("Вы сказали — да!");
}
else if (answer == "нет")
{
Console.WriteLine("Вы сказали — нет!");
}
else
{
Console.WriteLine("Непонятно. Попробуйте снова.");
goto Start; // Возвращаемся к метке Start
}
}
}
Пример использования goto на С++:
cpp
FILE* file1 = fopen("file1.txt", "r");
if (!file1) goto error;
FILE* file2 = fopen("file2.txt", "w");
if (!file2) goto error;
// Работа с файлами...
fclose(file1);
fclose(file2);
return 0;
error:
if (file1) fclose(file1);
if (file2) fclose(file2);
return -1;
Спагетти – код
— это код, порядок выполнения которого напоминает тарелку со спагетти (всё запутано и закручено), что крайне затрудняет следование порядку и понимание логики выполнения такого кода.
§3.2 Циклические алгоритмы
Циклические алгоритмы
— это управляющие структуры, предназначенные для многократного выполнения одного и того же блока кода до тех пор, пока выполняется заданное условие или не будет пройден заданный диапазон значений. Последовательность действий, предназначенная для многократного исполнения, называется телом цикла.
Они необходимы в тех случаях, когда одну и ту же операцию нужно повторить много раз, но писать её вручную для каждого повторения неэффективно и непрактично. Циклы позволяют автоматизировать повторяющиеся действия, что делает программы компактными, гибкими и универсальными.
Например, циклы используются для:
- Обработки массивов и списков.
- Ввода и проверки данных с повторением при ошибке.
- Вычисления сумм, произведений, факториалов.
- Моделирования процессов, происходящих во времени.
§3.2.1 Цикл с предусловием while
Цикл while
— это один из базовых операторов циклического выполнения, который предназначен для многократного выполнения блока кода при истинности заданного условия. Так как условие проверяется до входа в тело цикла, такой цикл называется циклом с предусловием.
Синтаксис на С++ и С# одинаков:
text
while (условие)
{
// тело цикла
}
Цикл работает следующим образом:
- Проверяется условие.
- Если оно истинно (true) — выполняется тело цикла.
- После выполнения тела управление возвращается к началу — условие проверяется снова.
- Если условие ложно (false) — цикл завершается, и программа продолжается дальше.
Для примера можно рассмотреть пример простого счетчика:
csharp
int i = 1;
while (i <= 3)
{
Console.WriteLine($"Итерация: {i}");
i++;
}
Данная программа выведет следующее:
text
Итерация: 1 Итерация: 2 Итерация: 3
Здесь переменная i увеличивается на 1 в каждой итерации. Как только i становится равным 4, условие i <= 3 становится ложным, и цикл завершается.
Если условие в while никогда не становится ложным, цикл будет выполняться бесконечно.
Первый случай бесконечного цикла
csharp
while (true)
{
Console.WriteLine("ВЕЧНОСТЬ");
}
Второй случай бесконечного цикла
csharp
while (1)
{
Console.WriteLine("ВЕЧНОСТЬ");
}
Такой цикл намеренно используется, когда программа должна работать непрерывно (например, сервер, игра, меню), а выход из цикла организуется внутри с помощью break, return или условия.
csharp
while (true)
{
Console.Write("Введите 'выход' для завершения: ");
string input = Console.ReadLine();
if (input == "выход")
{
Console.WriteLine("Программа завершена.");
break; // выходим из цикла
}
Console.WriteLine("Вы не вышли. Попробуйте снова.");
}
Счетчик цикла
— это целочисленная переменная, которая объявляется с единственной целью: считать, сколько раз выполнился цикл.
Счетчикам цикла часто дают простые имена, такие как i, j или k. А еще лучше использовать «реальные» имена для переменных, например, count или любое другое имя, которое предоставляет контекст использования этой переменной (например, number).
Каждое выполнение цикла называется итерацией (или «повтором»).
Поскольку тело цикла обычно является блоком, и поскольку этот блок выполняется по новой с каждым повтором, то любые переменные, объявленные внутри тела цикла, создаются, а затем и уничтожаются по новой.
cpp
while (count <= 6)
{
int z;
cout << "Enter integer #" << count << ':';
cin >> z;
count++;
} // z уничтожается здесь по новой с каждой итерацией
Иногда нам может понадобиться выполнить что-то при достижении определенного количества итераций, например, вставить символ новой строки. Это легко осуществить, используя оператор остатка от деления со счетчиком цикла, как представлено ниже:
cpp
int count = 1;
while (count <= 30)
{
// Выводим числа до 10 (перед каждым числом добавляем0)
if (count < 10)
{
cout << "0" << count << " ";
}
else
{
cout << count << " ";
}
// Если счетчик цикла делится на 10 без остатка, то тогда
// вставляем символ новой строки
if (count % 10 == 0)
{
cout << "\n";
}
// Увеличиваем значение счетчика цикла на единицу
++count;
}
Результат выполнения программы:
wireframe
01 02 03 04 05 06 07 08 09 10
11 12 13 14 15 16 17 18 19 20
21 22 23 24 25 26 27 28 29 30
Также одни циклы while могут быть вложены внутри других циклов while. В листинге ниже внутренний и внешний циклы имеют свои собственные счетчики. Однако, обратите внимание, условие внутреннего цикла использует счетчик внешнего цикла.
csharp
using System;
class Program
{
static void Main()
{
int outer = 1;
while (outer <= 5)
{
int inner = 1;
while (inner <= outer)
{
Console.Write(inner++ + " ");
}
// Вставляем символ новой строки в конце каждого ряда
Console.WriteLine();
++outer;
}
}
}
Результат выполнения программы:
wireframe
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
§3.2.2 Цикл с постусловием do – while
Цикл с постусловием do – while
— это управляющая конструкция, предназначенная для организации повторяющегося выполнения блока кода с гарантией его хотя бы одного выполнения.
В отличие от цикла с предусловием while, в котором условие проверяется до входа в тело, в do – while условие проверяется после выполнения тела цикла.
text
do
{
// тело цикла
} while (условие);
Обратите внимание:
- Тело цикла заключено между do и while.
- Условие записывается после тела и завершается точкой с запятой — это единственный случай в C-подобных языках, когда while заканчивается на точку с запятой.
Принцип работы:
- Выполняется тело цикла (хотя бы один раз).
- Проверяется условие продолжения.
- Если условие истинно (true) — цикл повторяется.
- Если условие ложно (false) — цикл завершается, и выполнение переходит к следующему оператору.
Таким образом, цикл do – while реализует логику: «Сделай это хотя бы раз, а потом решай — повторять ли».
csharp
char choice;
do
{
Console.WriteLine("\nМеню:");
Console.WriteLine("1. Начать игру");
Console.WriteLine("2. Настройки");
Console.WriteLine("3. Выход");
Console.Write("Выберите пункт: ");
choice = Console.ReadKey().KeyChar;
Console.WriteLine();
switch (choice)
{
case '1': Console.WriteLine("Игра начата!");
break;
case '2': Console.WriteLine("Настройки открыты.");
break;
case '3': Console.WriteLine("Выход...");
break;
default: Console.WriteLine("Неверный выбор.");
break;
}
} while (choice != '3');
Программа всегда показывает меню хотя бы один раз, даже если пользователь сразу выберет «Выход».
Переменная choice должна быть объявлена вне блоков do / while. Если бы переменная choice была объявлена внутри блока do, то она была бы уничтожена при завершении этого блока еще до проверки условия while. Но нам нужна переменная, которая будет использоваться в условии while, следовательно, переменная choice должна быть объявлена вне блока do.
§3.2.3 Цикл со счетчиком for
Цикл for
— это одна из наиболее часто используемых управляющих конструкций в языках C# и C++. Он предназначен для организации повторяющегося выполнения блока кода с заранее известным или контролируемым количеством итераций, что делает его идеальным выбором в случаях, когда требуется выполнить действие определенное число раз или пройти по последовательности значений.
В С# и C++ единый синтаксис цикла for:
text
for (инициализация; условие; обновление)
{
// тело цикла
}
Цикл for состоит из трёх компонентов, заключённых в круглые скобки и разделённых точкой с запятой:
- Инициализация — выполняется один раз при входе в цикл. Обычно здесь объявляется и инициализируется счётчик.
- Условие — логическое выражение, проверяемое перед каждой итерацией. Если оно истинно (true) — цикл продолжается; если ложно — завершается.
- Обновление — выражение, выполняемое после каждой итерации (чаще всего — изменение счётчика: инкремент, декремент и т.п.).
Принцип работ:
- Выполняется инициализация.
- Проверяется условие.
- Если условие истинно — выполняется тело цикла.
- После тела — выполняется обновление.
- Управление возвращается к проверке условия.
- Цикл повторяется, пока условие остаётся истинным.
Если условие изначально ложно, тело цикла не выполнится ни разу.
Пример вывода чисел от 1 до 5:
csharp
for (int i = 1; i <= 5; i++)
{
Console.WriteLine($"Итерация: {i}");
}
что выведет:
text
Итерация: 1
Итерация: 2
Итерация: 3
Итерация: 4
Итерация: 5
Конструкция for чрезвычайно гибкая:
- Любое выражение инициализации: можно объявить несколько переменных (в C++), или не объявлять вообще.
- Любое логическое условие: простое сравнение, сложное выражение с логическими операторами.
- Любое обновление: i++, i--, i += 2, i *= 2 и т.д.
На счет первого пункта. В C# нельзя напрямую объявить две переменные в заголовке одного for – цикла, в отличие от языков вроде C или C++, где это допускается при условии, что они одного типа.
Неправильно (так нельзя в C#):
csharp
for (int i = 0, j = 10; i < j; i++, j--) // Ошибка компиляции
{
// ...
} // ВНИМАНИЕ! В С++ ТАКОЕ РАЗРЕШАЕТСЯ
Но такое можно обойти, если объявить переменные до цикла.
csharp
int i, j;
for (i = 0, j = 10; i < j; i++, j--)
{
Console.WriteLine($"i = {i}, j = {j}");
}
Пример: счётчик в обратном порядке
csharp
for (int i = 5; i >= 1; i--)
{
Console.WriteLine(i);
}
Пример: шаг 2
csharp
for (int i = 0; i < 10; i += 2)
{
Console.WriteLine(i); // 0, 2, 4, 6, 8
}
По аналогии с циклом while, если условие всегда истинно, цикл будет выполняться бесконечно.
csharp
for (int i = 0; true; i++)
{
Console.WriteLine($"Бесконечность: {i}");
}
Но чаще всего используется каноническая форма бесконечного for:
csharp
for (;;)
{
Console.WriteLine("Я работаю вечно!");
}
§3.2.4 Цикл на основе диапазона foreach
Цикл foreach
— это специализированная управляющая конструкция, предназначенная для упрощённого перебора элементов коллекции или контейнера. В отличие от циклов с явным управлением (for, while), foreach абстрагирует программиста от деталей индексации и итерирования, предоставляя прямой доступ к каждому элементу коллекции по одному за раз.
Цель foreach — обеспечить безопасный, читаемый и удобный способ обхода всех элементов последовательности, таких как массивы, списки, строки, множества и другие перечисляемые структуры. Он реализует принцип: «Для каждого элемента в коллекции выполнить действие».
Этот подход особенно полезен, когда: требуется обработать все элементы, нет необходимости в явной работе с индексами и важно избежать ошибок, связанных с выходом за границы.
Синтаксис цикла:
text
foreach (тип_элемента переменная in коллекция)
{
// тело цикла
}
Пример:
csharp
string text = "C#";
foreach (char c in text)
{
Console.WriteLine(c); // Вывод: C, # (по символам)
}
В C++ нет foreach как ключевого слова, но начиная с C++11, введён range-based for — функциональный аналог:
cpp
for (auto& элемент : контейнер)
{
// тело цикла
}
Пример:
cpp
#include <iostream>
#include <string>
using namespace std;
int main()
{
string text = "C++";
for (char c : text)
{
cout << c << endl; // Вывод: C, +, + (по символам)
}
return 0;
}
§3.2.5 Операторы break и continue
Операторы break и continue являются вспомогательными средствами управления ходом выполнения циклов. Они позволяют нарушить стандартный порядок итераций в зависимости от условий, возникающих в ходе выполнения программы. Оба оператора используются внутри тела цикла и оказывают непосредственное влияние на его поведение, обеспечивая гибкость и точность управления потоком.
Оператор break немедленно прерывает выполнение текущего цикла и передаёт управление следующему оператору после цикла.
Применение:
- Досрочный выход из цикла при выполнении условия.
- Выход из switch (в C# и C++).
- Прерывание поиска, обработки ошибок, выход из бесконечного цикла.
Пример на С#:
csharp
int i = 1;
while (i <= 10)
{
if (i == 5)
{
break; // выход из цикла
}
Console.WriteLine($"i = {i}");
i++;
}
Console.WriteLine("Цикл завершён.");
Вывод:
text
i = 1
i = 2
i = 3
i = 4
Цикл завершён.
Пример на С++:
cpp
#include <iostream>
using namespace std;
int main()
{
for (int i = 0; i < 6; i++)
{
if (i == 3)
{
break;
}
cout << "i = " << i << endl;
}
cout << "Цикл завершён." << endl;
return 0;
}
Вывод:
text
i = 0
i = 1
i = 2
Цикл завершён.
break работает только с ближайшим (внутренним) циклом. Чтобы выйти из вложенных циклов, требуется goto (в C#) или флаг (в C++).
Оператор continue прерывает текущую итерацию и переходит к следующей, пропуская оставшуюся часть тела цикла.
Применение:
- Пропуск определённых значений.
- Фильтрация данных.
- Упрощение условной логики без вложенных if.
Пример на C#:
csharp
for (int i = 1; i <= 5; i++)
{
if (i == 3)
{
continue; // пропустить итерацию
}
Console.WriteLine($"i = {i}");
}
Console.WriteLine("Цикл завершён.");
Вывод:
text
i = 1
i = 2
i = 4
i = 5
Цикл завершён.
Пример на С++:
cpp
while (i < 5)
{
i++;
if (i % 2 == 0)
{
continue; // пропустить чётные
}
cout << "Нечётное: " << i << endl;
}
Вывод:
text
Нечётное: 1
Нечётное: 3
Нечётное: 5
Цикл завершён.
Так же break и continue разрешается использовать вместе:
csharp
for (int i = 1; i <= 6; i++)
{
if (i == 3)
{
continue; // пропустить 3
}
if (i == 6)
{
break; // выйти перед 6
}
Console.WriteLine($"i = {i}");
}
Вывод:
text
i = 1
i = 2
i = 4
i = 5
В данном коде пропущено 3 из-за использования конструкции continue, 6 не достигнуто из-за break.