Урок 27. Управление выполнением программы C#: цикл For

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

Что такое управление выполнением программы?

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

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

• Циклы. Циклы позволяют повторно выполнять часть кода до тех пор, пока не будет выполнено условие. Структура цикла является предметом этой статьи.
• Условия. Операторы и структуры условной обработки позволяют выполнять код при выполнении условий. Мы посмотрим на них позже.
• Переходы. Операторы перехода (Jump) - это простые команды, которые передают управление программой другому оператору. Инструкции break и continue описаны в этой статье. Скандально известное заявление GOTO будет рассмотрено позже.
• Обработка исключений. Когда возникают исключения, вместо того, чтобы представлять пользователю ошибку и останавливать выполнение, они должны быть обработаны. Операторы обработки исключений позволяют это. Они будут описаны на следующих уроках.

Цикл for

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

int i;
string numbers = "";
 
for (i = 1; i <= 5; i++)
    numbers += i.ToString();
     
Console.WriteLine(numbers);                     // Outputs: "12345"

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

команда for ( инициализация ; условие ; итерация) ;

Раздел инициализация инструкции for обычно используется для присвоения начального значения переменной, которая будет использоваться в качестве переменной управления счетчиком или циклом . В приведенном выше примере счетчик " i " инициализируется единицей, которая является первой цифрой, добавляемой в строку. Раздел инициализации закрывается точкой с запятой (;).

Второй раздел называется условием. Это логический предикат, который должен быть true для выполнения кода в цикле. Если условие false до выполнения цикла один раз, код в цикле пропускается. В нашем примере условием является 'i<=5'. Таким образом, код будет выполняться, пока " i " остается на уровне или ниже пяти. Как только это ограничение превышено, цикл прекращает выполнение, и управление переходит к инструкции, следующей за циклом. Раздел условия закрывается точкой с запятой (;).

Раздел итерация содержит команду, выполняемую по завершении каждой итерации цикла. В примере переменная счетчика увеличивается после каждой итерации. В результате код в цикле выполняется пять раз со значением 'i', увеличивающимся каждый раз.

Разделы инициализация, условие и итерация управляют тем, как цикл будет работать во время выполнения. Эти три элемента составляют оператор for и заключены в скобки. Далее следует команда, которая будет выполняться во время каждой итерации. В нашем примере команда добавляет строковое представление счетчика к другой строке, которая в конечном итоге содержит текст "12345".

Использование блока кода для команды цикла

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

int[] squares = new int[11];
int i;
 
for (i = 0; i <= 10; i++)
{
    int squareValue = i * i;
    squares[i] = squareValue;
}

Обратите внимание, что целое значение 'squareValue' объявляется внутри цикла. Любая переменная, объявленная в блоке кода цикла, существует для одной итерации. При перезапуске цикла переменная уничтожается и должна быть воссоздана. Это означает, что переменная недоступна вне блока кода. Если переменная необходима вне цикла или должна сохраняться между итерациями, объявите ее перед инструкцией for.

Объявление переменной управления циклом в инициализации

В предыдущем примере переменная управления loop объявляется до выполнения цикла. По завершении цикла переменная все еще существует. Переменная будет содержать значение11 в то время, как это значение, которое вызывает условие цикла, чтобы быть ложным. Часто переменная управления циклом требуется только на время выполнения цикла. В этом случае он может быть объявлен в разделе инициализации инструкции for. По завершении цикла переменная становится недоступной.

int[] squares = new int[11];
 
for (int i = 0; i <= 10; i++)
{
    int squareValue = i * i;
    squares[i] = squareValue;
}

Несколько переменных управления циклом

Цикл for может включать несколько управляющих переменных, каждая из которых имеет независимую инициализацию и информацию об итерации. Комбинация переменных может быть включена в раздел условия цикла for. В следующем примере используются две управляющие переменные цикла. Обратите внимание, что разделы инициализации и итерации разделены запятыми.

for (int i = 0, j = 5; i <= j; i += 2, j++)
{
    Console.WriteLine("i = {0}, j = {1}", i, j);
}
 
/* Вывод
 
i = 0, j = 5
i = 2, j = 6
i = 4, j = 7
i = 6, j = 8
i = 8, j = 9
i = 10, j = 10
 
*/

Исключение переменной управления циклом из условия

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

int[] squares = new int[11];
bool finished = false;
 
for (int i = 0; !finished; i++)
{
    int squareValue = i * i;
    squares[i] = squareValue;
     
    finished = (i == 10) || (squareValue > 50); 
}

Использование неполных определений цикла

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

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

int[] squares = new int[11];
int i = 0;
 
for (; i <= 10; i++)
{
    int squareValue = i * i;
    squares[i] = squareValue;
}

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

for (int i=0; ; i++)
{
    Console.WriteLine("Цикл, итерация #{0}",i);
}

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

for (;;)
{
    Console.WriteLine("Бесконечно...");
}

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

int[] squares = new int[11];
 
for (int i = 0; i <= 10;)
{
    int squareValue = i * i;
    squares[i] = squareValue;
    i++;
}

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

int total = 0;
 
for (int i = 1; i <= 10; total += i++);
 
Console.WriteLine("Всего = {0}", total);        // Outputs "Total = 55"

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

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

int[,] table = new int[13,13];
 
// Внешний
for (int row = 0; row <= 12; row++)
{
    // Внутренний
    for (int col = 0; col <= 12; col++)
    {
        table[row,col] = row * col;
    }
}

Выход из цикла

Во время выполнения цикла for (или любой другой структуры цикла в C#), может быть необходимо выйти немедленно. Это всегда имеет место для бесконечного цикла, но может быть одинаково полезно, чтобы закончить цикл раньше, как только его цель выполнена. Для принудительного выхода из цикла используется инструкция break.

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

string[] items = new string[] {"A", "B", "C", "D", "E", "F", "G", "H"};
int pos;
 
for (pos = 0; pos <= items.Length; pos++)
{
    if (items[pos] == "C")
    {
        break;
    }
}
 
Console.WriteLine("C is at position {0}", pos); // Выведет "C в позиции 2"

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

Раннее завершение итерации цикла

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

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

for (int i = 0; i <= 100; i++)
{
    if ((i % 2) == 0) continue;
     
    Console.WriteLine(i);
}