Операторы цикла в языке C#

В C# имеются четыре различных вида циклов (for, while, do…while и foreach), позволяющие выполнять блок кода повторно до тех пор, пока удовлетворяется определенное условие.

Навыки циклических действий – первый признак профпригодности программиста, поэтому в нашем курсе много внимания уделено  работе со циклами.

Рассмотрим синтаксис операторов с примерами их применения.

Цикл for

Цикл for в C# предоставляет механизм итерации, в котором определенное условие проверяется перед выполнением каждой итерации.
Синтаксис этого оператора показан ниже:

for (инициализатор; условие; итератор) оператор (операторы);

Здесь:
инициализатор — это выражение, вычисляемое перед первым выполнением тела цикла (обычно инициализация локальной переменной в качестве счетчика цикла). Инициализация, как правило, представлена оператором присваивания, задающим первоначальное значение переменной, которая исполняет роль счетчика и управляет циклом;

условие — это выражение, проверяемое перед каждой новой итерацией цикла (должно возвращать true, чтобы была выполнена следующая итерация);

итератор – это выражение, вычисляемое после каждой итерации (обычно приращение значения счетчика цикла).

Обратите внимание на то, что эти три основные части оператора цикла for должны быть разделены точкой с запятой.

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

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

Стоит отметить, что цикл for отлично подходит для повторного выполнения оператора или блока операторов заранее известное количество раз. Давайте рассмотрим практическое применение цикла for на примере:

using System;
namespace ConsoleApplication1
{    
   class Program
   {        
      // Данный метод выводит таблицу умножения
      // размерностью b x b        
         static void tab(byte b) 
         {            
            Console.WriteLine("Таблица умножения {0} x {0}\n", b);
            // Этот цикл проходит по строкам
            for (int i = 1; i <= b; i++)
            {                
               // Этот цикл проходит по столбцам
               for (int j = 1; j <= b; j++) 
                  Console.Write("{0}\t", j * i);    
               Console.WriteLine();
            }
         }
         static void Main(string[] args)        
         {
            tab(10);
         // Нестандартные возможности цикла for  
      // 1. Применение нескольких переменных управления циклом
            for (byte i = 0, j = 20; i <= j; i += 5, j -= 5) 
               Console.WriteLine("i = {0}, j = {1}", i, j);
            Console.WriteLine();
      // 2. Использование условного выражения в цикле
            bool b = false;
            for (byte i = 1, j = 100; !b; i++, j--)
               if (i < Math.Sqrt(j))
                  Console.WriteLine("Число {0} меньше квадратного корня из {1}", i, j);
               else b = true;
      // 3. Отсутствие части цикла
            int k = 0; 
            for (; k < 10; ) 
            {               
               k++;
               Console.Write(k);
            }
           Console.WriteLine("\n");
      // 4. Цикл без тела
            int sum = 0;
            for (int i = 1; i <= 10; sum += ++i);
            Console.WriteLine("Значение суммы: {0}", sum);
            Console.ReadLine();
         }
    }
}

Результат:

Цикл while

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

while (условие) оператор (операторы);

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

В этом цикле оператор выполняется до тех пор, пока условие истинно.

Как только условие становится ложным, управление программой передается строке кода, следующей непосредственно после цикла.

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

Пример:

using System;
namespace ConsoleApplication1
{    
   class Program
   {
      static void Main(string[] args)
      {            
      // Пример возведения числа в несколько степеней
          byte p = 2, i = 0;
          int result = 1;
          while (i < 10)
          {
              i++;
              result *= p;
              Console.WriteLine("{0} в степени {1} равно {2}", p, i, result);
          }            
          Console.ReadLine();
      }
   }
}

Результат:

Цикл do…while

Цикл do…while (делай — пока) в C# — это версия while с постпроверкой условия. Это значит, что условие цикла проверяется после выполнения тела цикла.

Следовательно, циклы do…while удобны в тех ситуациях, когда блок операторов должен быть выполнен как минимум однажды.

Ниже приведена общая форма оператора цикла do-while:

do {операторы;} while (условие);

При наличии лишь одного оператора фигурные скобки в данной форме записи необязательны.

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

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

using System; 
namespace ConsoleApplication1
{    
   class Program    
   {        
      static void Main(string[] args)
         {
            try
            {  
               // Вычисляем факториал числа
               int n, result = 1, num = 1;
               Console.Write("Введите число:  ");
               n = int.Parse(Console.ReadLine());
               Console.Write("\nФакториал {0} = ", n);
               do
               {
                  result *= num;
                  num++;
               } while (num <= n);
               Console.Write(result);
            }
            catch (FormatException ex)            
            {
               Console.WriteLine("Вы ввели не число. {0}", ex.Message);
            }
            finally
            {
               Console.ReadLine();
            }
        }
    }
} 

Результат:

Цикл foreach

Цикл foreach служит для циклического обращения к элементам коллекции (см. далее), представляющей собой группу объектов.

В C# определено несколько видов коллекций, каждая из которых является массивом.
Ниже приведена общая форма оператора цикла foreach:

foreach (тип имя_переменной_цикла in коллекция) оператор;

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

А коллекция обозначает циклически опрашиваемую коллекцию, которая здесь и далее представляет собой массив. Следовательно, тип переменной цикла должен соответствовать типу элемента массива.

Кроме того, тип может обозначаться ключевым словом var. В этом случае компилятор определяет тип переменной цикла, исходя из типа элемента массива. Это может оказаться полезным для работы с определенного рода запросами. Но, как правило, тип указывается явным образом.

Оператор цикла foreach действует следующим образом.
Когда цикл начинается, первый элемент массива выбирается и присваивается переменной цикла.

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

Цикл завершается, когда все элементы массива окажутся выбранными.

Цикл foreach позволяет проходить по каждому элементу коллекции (объект, представляющий список других объектов). Формально для того, чтобы нечто можно было рассматривать как коллекцию, это нечто должно поддерживать интерфейс IEnumerable.

Примерами коллекций могут служить массивы C#, классы коллекций из пространства имен System.Collection, а также пользовательские классы коллекций.

Пример использования цикла foreach:

using System;
using System.Collections.Generic;
namespace ConsoleApplication1
{
   class Program
   {
      static void Main(string[] args)
      {
      // Объявляем два массива
         int[] myArr = new int[5];
         int[,] myTwoArr = new int[5, 6];
         int sum = 0;
         Random ran = new Random();
      // Инициализируем массивы
         for (int i = 1; i <= 5; i++)
         {
            myArr[i - 1] = ran.Next(1, 20);
            for (int j = 1; j <= 6; j++)
               myTwoArr[i - 1, j - 1] = ran.Next(1, 30);
         }
      // Вычисляем квадрат каждого элемента одномерного массива
         foreach (int fVar in myArr)
            Console.WriteLine("{0} в квадрате равно {1}", fVar, fVar * fVar);
         Console.WriteLine();
      // Вычислим сумму элементов многомерного массива
         foreach (int fTwoVar in myTwoArr)
            sum += fTwoVar;
         Console.WriteLine("Сумма элементов многомерного массива: {0}", sum);
         Console.ReadLine();
      }
   }
}

Попробуйте запустить данный пример несколько раз и вы наглядно увидите, что элементы массива изменяются каждый раз (с помощью метода Random.Next), и соответственно опрашиваются в цикле foreach, например:

Внимание! Об ограниченности применения цикла foreach:

При компиляции конструкции:

int[] myArr = new int[5];
int k=0;
foreach (int fVar in myArr)
   fVar=k++;

возникает ошибка:
Невозможно присвоить «fVar» значение, поскольку он является «переменная цикла foreach».

Это означает, в данном типе цикла изменить элемент массива невозможно, и следует использовать другие конструкции цикла.

Примечание автора

Непонимание циклических действий – первый признак профнепригодности программиста. Совет: научитесь программировать циклы без ошибок.

Далее рассматриваются операторы перехода.

---

NEW: Наш Чат, в котором вы можете обсудить любые вопросы, идеи, поделиться опытом или связаться с администраторами.

---

Помощь проекту: