07.09.2023 в 17:44

Циклы в C#

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

for
foreach
while
do…while

Цикл for

Цикл for имеет следующее формальное определение:

for ([actions_before loop execution]; [condition]; [actions after execution])
{ 
// actions
}

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

Вторая часть - это условие, при котором цикл будет выполнен. Пока условие выполняется, цикл будет выполняться.

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

После объявления цикла действия цикла заключаются в фигурные скобки.

Рассмотрим стандарт для цикла:

for (int i = 1; i < 4; i++)
{
    Console.WriteLine(i);
}

Здесь первая часть объявления цикла - int i = 1 - создает и инициализирует переменную i.

Вторая часть - это условие i < 4. То есть до тех пор, пока переменная i меньше 4, цикл будет выполняться.

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

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

Определена переменная int i = 1.

Проверяется условие i < 4. Это верно (поскольку 1 меньше 4), поэтому выполняется блок цикла, а именно оператор Console.WriteLine(i), который выводит значение переменной i на консоль.

Выполнение блока цикла завершено, поэтому выполняется третья часть объявления цикла, i++. После этого переменная i будет равна 2.

Условие i < 4 проверяется еще раз. Это верно (потому что 2 меньше, чем 4), поэтому блок цикла выполняется снова - Console.WriteLine(i).

Блок цикла завершил выполнение, поэтому выражение i++ выполняется снова. После этого переменная i будет равна 3.

Условие i < 4 проверяется еще раз. Это верно (поскольку 3 меньше 4), поэтому блок цикла выполняется снова - Console.WriteLine(i).

Блок цикла завершил выполнение, поэтому выражение i++ выполняется снова. После этого переменная i будет равна 4.

Условие i < 4 проверяется еще раз. Теперь он возвращает значение false, потому что i равно НЕ менее 4, поэтому цикл завершается. Затем уже выполняется остальная часть программы, которая следует за циклом.

В результате блок цикла будет выполняться 3 раза до тех пор, пока значение i не станет равным 4. И каждый раз это значение будет увеличиваться на 1. Однократное выполнение блока цикла называется итерацией. Итак, здесь цикл выполнит три итерации.

Результат работы программы:

1
2
3

Если блок цикла for содержит один оператор, то мы можем сократить его, удалив фигурные скобки:

for (int i = 1; i < 4; i++)
    Console.WriteLine(i);

// or so
for (int i = 1; i < 4; i++) Console.WriteLine(i);

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

var i = 1;

for (Console.WriteLine("Begin loop"); i < 4; Console.WriteLine($"i = {i}"))
{
    i++;
}

Здесь снова цикл выполняется, пока переменная i меньше 4, в блоке цикла происходит только приращение переменной i. Консольный вывод этой программы:

Starting a loop
i = 2
i = 3
i = 4

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

int i = 1;
for (; ;)
{
    Console.WriteLine($"i = {i}");
    i++;
}

Формально определение цикла остается прежним, только теперь блоки в определении пустые: for (; ;). У нас нет инициализированной переменной, нет условия, поэтому цикл будет выполняться вечно - бесконечный цикл.

Мы также можем опустить ряд блоков:

int i = 1;
for (; i<4;)
{
    Console.WriteLine($"i = {i}");
    i++;
}

Этот пример по сути эквивалентен первому примеру: у нас также есть переменная counter, только она определена вне цикла. У нас есть условие выполнения цикла. И есть приращение переменной уже в самом блоке for.

Также стоит отметить, что вы можете определить несколько переменных в объявлении цикла:

for (int i = 1, j = 1; i < 10; i++, j++)
    Console.WriteLine($"{i * j}");

Здесь, в первой части объявления цикла, определены две переменные: i и j. Цикл выполняется до тех пор, пока i не станет равным 10. После каждой итерации переменные i и j увеличиваются на единицу. Консольный вывод программы:

Цикл do..while

В цикле do сначала выполняется код цикла, а затем проверяется условие в операторе while. И пока это условие выполняется, цикл повторяется.

do
{
    cycle actions
}
while (condition)

Пример:

int i = 6;
do
{
    Console.WriteLine(i);
    i--;
}
while (i > 0);

Здесь код цикла будет выполняться 6 раз, пока значение i не станет равным нулю. Но важно отметить, что цикл do гарантирует, что действия будут выполнены хотя бы один раз, даже если условие в операторе while не является истинным. То есть, мы можем написать:

int i = -1;
do
{
    Console.WriteLine(i);
    i--;
}
while (i > 0);

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

Цикл while

В отличие от цикла do, цикл while немедленно проверяет истинность некоторого условия, и если условие истинно, то выполняется код цикла:

while (condition)
{
    cycle actions
}

Пример:

int i = 6;
while (i > 0)
{
    Console.WriteLine(i);
    i--;
}

Цикл foreach

Цикл foreach предназначен для выполнения итерации по набору или коллекции элементов. Его общее определение таково:

foreach(datatype variable in collection)
{
    // cycle actions
}

После оператора foreach в круглых скобках сначала следует определение переменной. Затем ключевое слово in, а затем коллекция, элементы которой должны быть перебраны.

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

Например, давайте возьмем строку. Строка - это, по сути, набор символов. И .NET позволяет вам перебирать все элементы строки - ее символы с помощью цикла foreach.

foreach(char c in "Tom")
{
    Console.WriteLine(c);
}

Здесь цикл foreach перебирает все символы в строке "Tom" и помещает каждый символ в символьную переменную c. В блоке цикла значение переменной c выводится на консоль. Поскольку в строке "Tom" содержится три символа, цикл будет выполнен три раза. Консольный вывод программы:

T
O
M

Стоит отметить, что переменная, определенная в объявлении цикла, должна соответствовать типу элементов повторяемой коллекции. Итак, элементами строки являются значения типа char - characters. Таким образом, переменная c имеет тип char. Однако на самом деле не всегда очевидно, какой тип представляют элементы коллекции. В этом случае мы можем определить переменную, используя оператор var:

foreach(var c in "Tom")
{
    Console.WriteLine(c);
}

Далее мы более подробно рассмотрим, какие коллекции есть в .NET и какие коллекции можно перебирать с помощью цикла foreach.

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

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

Например:

for (int i = 0; i < 9; i++)
{
    if (i == 5)
        break;
    Console.WriteLine(i);
}

Хотя условие цикла гласит, что цикл будет выполняться до тех пор, пока счетчик i не достигнет 9, на самом деле цикл будет выполняться 5 раз. Поскольку, когда счетчик i достигнет значения 5, оператор break сработает, и цикл завершится.

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

for (int i = 0; i < 9; i++)
{
    if (i == 5)
        continue;
    Console.WriteLine(i);
}

В этом случае цикл, когда он достигнет числа 5, которое не удовлетворяет условию тестирования, просто пропустит это число и перейдет к следующей итерации:

Стоит отметить, что операторы break и continue могут использоваться в цикле любого типа.

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

Некоторые циклы могут быть вложены в другие. Например:

for (int i = 1; i < 10; i++)
{
    for (int j = 1; j < 10; j++)
    {
        Console.Write($"{i * j} \t");
    }
    Console.WriteLine();
}

В этом случае цикл for (int i = 1; i < 10; i++) выполняется 9 раз, то есть имеет 9 итераций. Но в пределах каждой итерации вложенный цикл for (int j = 1; j < 10; j++) выполняется девять раз. В результате эта программа выведет на экран таблицу умножения.

Мой GitHub

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

1.metanit

Источник:

Comment button

#Начинающим

Войти на сайт