Выполнение оператора цикла 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 ic 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(); } } ic 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 { ic 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 { ic 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 { ic 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».
Это означает, в данном типе цикла изменить элемент массива невозможно, и следует использовать другие конструкции цикла.
Примечание автора
Непонимание циклических действий – первый признак профнепригодности программиста. Совет: научитесь программировать циклы без ошибок.
Далее рассматриваются операторы перехода.
Источник
Циклы
Последнее обновление: 19.06.2017
Циклы являются управляющими конструкциями, позволяя в зависимости от определенных условий выполнять некоторое действие множество раз. В C# имеются следующие виды циклов:
for
foreach
while
do…while
Цикл for
Цикл for имеет следующее формальное определение:
for ([инициализация счетчика]; [условие]; [изменение счетчика]) { // действия }
Рассмотрим стандартный цикл for:
for (int i = 0; i < 9; i++) { Console.WriteLine($”Квадрат числа {i} равен {i*i}”); }
Первая часть объявления цикла – int i = 0 – создает и инициализирует счетчик i. Счетчик необязательно должен представлять тип int. Это может быть и другой числовой тип, например, float. И перед выполнением цикла его значение будет равно 0. В данном случае это то же самое, что и объявление переменной.
Вторая часть – условие, при котором будет выполняться цикл. Пока условное выражение возвращает true, будет выполняться цикл. В данном случае цикл будет выполняться, пока счетчик i не достигнет 9.
И третья часть – приращение счетчика на единицу. Опять же нам необязательно увеличивать на единицу. Можно уменьшать: i–.
В итоге блок цикла сработает 9 раз, пока значение i не станет равным 9. И каждый раз это значение будет увеличиваться на 1.
Нам необязательно указывать все условия при объявлении цикла. Например, мы можем написать так:
int i = 0; for (; 😉 { Console.WriteLine($”Квадрат числа {++i} равен {i * i}”); }
Формально определение цикла осталось тем же, только теперь блоки в определении у нас пустые: for (; i <;). У нас нет инициализированной переменной-счетчика, нет условия, поэтому цикл будет работать вечно – бесконечный цикл.
Мы также можем опустить ряд блоков:
int i = 0; for (; i<9;) { Console.WriteLine($”Квадрат числа {++i} равен {i * i}”); }
Этот пример по сути эквивалентен первому примеру: у нас также есть счетчик, только создан он вне цикла. У нас есть условие выполнения цикла. И есть приращение счетчика уже в самом блоке for.
Цикл do
В цикле do сначала выполняется код цикла, а потом происходит проверка условия в инструкции while. И пока это условие истинно, цикл повторяется. Например:
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 сразу проверяет истинность некоторого условия, и если условие истинно, то код цикла выполняется:
int i = 6; while (i > 0) { Console.WriteLine(i); i–; }
Операторы 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, которое не удовлетворяет условию проверки, просто пропустит это число и перейдет к следующей итерации:
Цикл foreach
Цикл foreach перебирает коллекции, например, массивы, и будет рассмотрен далее в теме массивов.
Источник
Что мы делаем ежедневно? Думаю, у каждого из нас свой список дел. Однако раз за разом повторяются одни и те же операции для достижения одних и тех же целей. Это и есть цикл. В программировании циклы используются при обработке множеств / файлов или же для вычисления математических выражений.
Смотрите моё видео на тему Циклы C#
Подпишись на группу Вконтакте и Телеграм-канал. Там еще больше полезного контента для программистов.
А на YouTube-канале ты найдешь обучающие видео по программированию. Подписывайся!
Выделяют несколько видов циклов:
- while … do (с предусловием );
- do … while (с постусловием);
- for (с параметром)
Цикл с параметром – Цикл for C#
Может использоваться в ситуациях, когда до входа в цикл известно количество итераций (повторений цикла). Имеет следующий вид:
for(<инициализация>; <условие>; <порядок выполнения>) { <действия> }
- Инициализация – установка начальных параметров счетчика;
- Условие – условие выхода из цикла, как только оно вернет ложь – произойдет выход из цикла;
- Порядок выполнения – команда увеличения счетчика.
Действия, выполняемые циклически, называются телом цикла. Рассмотрим наиболее общий пример: поиск факториала числа. Факториал числа вычисляется по формуле:
N = 1 * 2 * 3 * … * N
Как вы видите, мы заранее знаем, сколько раз должно повториться тело цикла, потому можем использовать счетчик.
int n = Convert.ToInt32(Console.ReadLine()); // Пользователь вводит число. int factorial = 1; for(int i = 2; i <= n; i++) // Вычисление факториала. { factorial *= i; } Console.WriteLine(factorial); // Выводим факториал пользователю.
Итак, пользователь вводит любое число. После чего, мы вычисляем факториал по вышеуказанной формуле. Начальное значение факториала необходимо установить в единицу. Цикл начинаем с двойки и повторяем до тех пор, пока счетчик меньше или равен введенному пользователем значению. Если использовать оператор «меньше», мы потеряем умножение на старшее число при вычислении факториала. Порядок выполнения указан как i++, это значит, что на каждой итерации цикла счетчик i увеличивается на единицу. В виде порядка управления может выступать и более сложная математическая формула.
Цикл с предусловием – Цикл while C#
В данном случае действия цикла повторяются до тех пор, пока выполняется указанное условие. Этот цикл функционирует по принципу: «Сперва думаем, после делаем». В общем виде выглядит так:
while(<Условие>) { <Действия> }
Рассмотрим пример вычисления факториала при помощи while.
int n = Convert.ToInt32(Console.ReadLine()); // Пользователь вводит число. int factorial = 1; int i = 2; while(i <= n) // Вычисление факториала. { factorial *= i; i++; // Увеличиваем счетчик. } Console.WriteLine(factorial); // Выводим факториал пользователю.
Чтобы не получить бесконечного цикла, необходимо изменять параметр, проверяемый в условии. Именно для этого мы увеличиваем i.
Цикл с постусловием – Цикл do while C#
Этот вид цикла подобен while, с той лишь разницей, что проверка условия производится после выполнения тела цикла.
do { <Действия> } while(<Условие>);
И снова рассмотрим вычисление факториала.
int n = Convert.ToInt32(Console.ReadLine()); // Пользователь вводит число. int factorial = 1; int i = 2; do // Вычисление факториала. { factorial *= i; i++; // Увеличиваем счетчик. } while(i <= n); Console.WriteLine(factorial); // Выводим факториал пользователю.
Перебор коллекций – Цикл foreach C#
Допустим, мы имеем массив значений, не важно каких: числа, строки, символы… Для перебора массива удобно использовать этот вид цикла. Выглядит он следующим образом:
foreach(var <Элемент массива> in <Массив>) { <Действия> }
Предположим, у нас есть список городов, и нужно найти все города, начинающиеся с заданного символа.
var sym = Console.ReadKey(); // Читаем символ с клавиатуры var cities = {“Москва”, “Казань”, “Петергоф”, “Пермь”, “Минск”, “Сан-Диего”, “Вызима”}; var founded = “”; // Найденные города. foreach(var city in cities) { if(city.StartsWith(sym)) { founded += city + ” “; } } Console.WriteLine(founded);
Пользователь вводит символ, после чего для каждого элемента массива проверяется, начинается ли он с заданного символа. И, если условие выполняется, элемент массива запоминается в результирующей строке. Главным плюсом foreach является то, что он исключает возможность выхода за границы массива.
Управление циклом. Команды break и countinue
Для управления циклом в языке C# используются два оператора: break и continue.
Оператор break используется для прерывания выполнения цикла. Пусть, нам нужно найти некоторый элемент в массиве. Так, используя цикл, мы можем выйти из цикла, как только найдем искомый элемент.
int index = 0; var wanted = Console.ReadLine(); var array; for(int i = 0; i < array.Length; i++) { if(array[i] == wanted) { index = i; break; } }
Так мы находим индекс искомого слова в массиве, при этом не выполняем лишних операций после того, как найдем искомый элемент.
Оператор continue используется для перехода к следующей итерации цикла. Рассмотрим задачу: необходимо вычислить сумму пяти частных вида:
1 / (i – a)
Как вы видите, при i = a будет получена ошибка «Деление на ноль». В данном случае мы можем пропускать значение счетчика, которое приводит к ошибке.
var sum = 0; for(int i = 0; i < n; i++) { if (i – a == 0) { continue; } sum+= 1 / (i – a); }
Циклы C# – Итоги
Вот мы и рассмотрели основы работы с циклами в C#. Удачных вам экспериментов, коллеги.
Рекомендую также изучить статью Логические операции и условные операторы C#. А также подписывайтесь на группу ВКонтакте, Telegram и YouTube-канал. Там еще больше полезного и интересного для программистов.
Источник
Циклы чрезвычайно важны в программирования на C++, да и в остальных языках. Начнем с теории.
Цикл – это повторение одного и того же участка кода в программе. Последовательность действий, которые повторяются, называют телом цикла. Один проход цикла – это шаг или итерация. Переменные, изменяющиеся внутри цикла и влияющие на его окончание, называются параметрами цикла.
В C++ предусмотрены три оператора, реализующих циклический процесс: while, do..while и for. Рассмотрим каждый из них.
Оператор с предусловием (while)
Он работает следующим образом. Вычисляется значение выражения. Если оно истинно, то выполняется оператор. В противном случае цикл заканчивается. Если состоит более чем из одного оператора, необходимо использовать составной оператор:
while условие
{
оператор_1;
оператор_2;
…
оператор_n;
}
Рассмотрим пример. Пусть нам необходимо составить программу, которая в зависимости от возраста пользователя определяла сколько лет ему осталось до выхода на пенсию. При условии, что пенсионный возраст наступает в 56 лет.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | #include “stdafx.h” #include <iostream> using namespace std; int main () { int x, y, i, pen; //описаваем нужные переменные x=0; //стартовое значение переменной y=56; //определяем пенсионный возраст while (x<=3) //пока параметр цикла не превышает конечное значение. //выполнять тело цикла { cout<<“How old are you? n”; cin>>i; pen=y-i; cout<<“Remained until retirement (years) = “<<pen<<endl; x++; //изменение параметра цикла (аналогично x=x+1 (расмотрим в последующих уроках)) } system (“pause”); return 0; } |
Вот результат работы программы:
Цикл с постусловием (do…while)
Иногда возникает необходимость, чтобы тело цикла выполнилось хотя бы один раз, но условие не позволяет этому случится. Вот именно тут нам поможет цикл с постусловие do…while. Который реализован следующей конструкцией:
do оператор while (выражение);
Работает цикл следующим образом. В начале выполняется оператор, затем вычисляется значение выражения. Если оно истинно, оператор тела цикла выполняется еще раз.
Рассмотрим код на примере прошлой программы, изменив некоторые строки.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 | #include “stdafx.h” #include <iostream> using namespace std; int main () { int x, y, i, pen; //описаваем нужные переменные x=0; //стартовое значение переменной y=56; //определяем пенсионный возраст do { cout<<“How old are you? n”; cin>>i; pen=y-i; cout<<“Remained until retirement (years) = “<<pen<<endl; x++; //изменение параметра цикла (аналогично x=x+1) } while (x<=-1); //условие ложно, но цикл выполняется 1 раз system (“pause”); return 0; } |
Цикл с параметром (for)
Данный цикл можно представить такой конструкцией;
for (начальные_присваивания; выражение; приращение) оператор;
Здесь начальные_присваивания – оператор или группа операторов, применяемые для присвоения начальных значений величинам используемым в цикле; выражение – определяет условие выполнения цикла, если оно истинно, то цикл выполняется; приращение – оператор, который выполняется после каждого шага (прохода) по телу цикла; оператор – любой оператор.
Давайте на примере задачи рассмотрим цикл с параметром. Нам необходимо посчитать сумму чисел от 1 до 500. Делаем:
#include “stdafx.h” #include <iostream> using namespace std; int main () { int i; //определяем переменную int sum = 0; for (i=1; i<=500; i=i+1) // задаем начальное значение, конечное 500, шаг цикла { sum = sum + i; } cout << “The sum of the numbers from 1 to 500 = ” <<sum<<endl; system (“pause”); return 0; } |
Ответ будет 125250.
Похожие записи:
- Указатели в C++
- Visual C++. Использование MFC-приложений
- Hellow, Word, первая программа на языке C++
- Классы в C++. ООП. Конструктор
- Рекурсивные функции с C++. Перегрузка
Источник