П ри решении практических задач постоянно возникает необходимость в повторении действия заданное количество раз, или до достижения какого-либо условия. Например, вывести список всех пользователей, замостить плоскость текстурой, провести вычисления над каждым элементом массива данных и т.п. В си для этих целей используются три вида циклов: с предусловием, постусловием и цикл for со счётчиком (хотя, это условное название, потому что счётчика может и не быть).
Любой цикл состоит из тела и проверки условия, при котором этот цикл должен быть прекращён. Тело цикла — это тот набор инструкций, который необходимо повторять. Каждое повторение цикла называют итерацией.
Рассмотрим цикл с предусловием.
int i = 0; while (i
Этот цикл выполняется до тех пор, пока истинно условие, заданное после ключевого слова while. Тело цикла — это две строки, одна выводит число, вторая изменяет его. Очевидно, что этот цикл будет выполнен 10 раз и выведет на экран
0
1 2 3 и так далее до 9.
Цикл for. Что это. Что делает. Пример. Синтаксис. Циклы. Урок #16.
Очень важно, чтобы условие выхода из цикла когда-нибудь выполнилось, иначе произойдёт зацикливание, и программа не завершится. К примеру
int i = 0; while (i
В этом цикле не изменяется переменная i, которая служит для определения условия останова, поэтому цикл не завершится.
int i = 0; while (i > 0)
В этой программе цикл, конечно, завершится, но из-за неправильного действия он будет выполнен гораздо больше 10 раз. Так как си не следит за переполнением переменной, нужно будет ждать, пока переменная переполнится и станет меньше нуля.
int i; while (i
У этого примера неопределённое поведение. Так как переменная i заранее не инициализирована, то она хранит мусор, заранее неизвестное значение. При различном содержимом переменной i будет меняться поведение.
Если тело цикла while содержит один оператор, то фигурные скобки можно опустить.
int i = 0; while (i < 10) printf(«%dn», i++);
Здесь мы инкрементируем переменную i при вызове функции printf. Следует избегать такого стиля кодирования. Отсутствие фигурных скобок, особенно в начале обучения, может приводить к ошибкам. Кроме того, код читается хуже, да и лишние скобки не сильно раздувают листинги.
Циклы с постусловием.
Ц икл с постусловием отличается от цикла while тем, что условие в нём проверяется после выполнения цикла, то есть этот цикл будет повторён как минимум один раз (в отличие от цикла while, который может вообще не выполняться). Синтаксис цикла
do < тело цикла >while(условие);
Предыдущий пример с использованием цикла do будет выглядеть как
int i = 0; do < printf(«%dn», i); i++; >while(i < 10);
Давайте рассмотрим пример использования цикла с постусловием и предусловием. Пусть нам необходимо проинтегрировать функцию.
∫ a b f x d x
Интеграл — это сумма бесконечно малых. Мы можем представить интеграл как сумму, а бесконечно малые значения просто заменить маленькими значениями.
Python с нуля. Урок 4 | Циклы (for, while)
∫ a b f x d x = ∑ i = a b f i h
Из формулы видно, что мы на самом деле разбили площадь под графиком на множество прямоугольников, где высота прямоугольника — это значение функции в точке, а ширина — это наш шаг. Сложив площади всех прямоугольников, мы тем самым получим значение интеграла с некоторой погрешностью.
Пусть искомой функцией будет x 2 . Нам понадобятся следующие переменные. Во-первых, аккумулятор sum для хранения интеграла. Во-вторых, левая и правая границы a и b, в третьих — шаг h. Также нам понадобится текущее значение аргумента функции x.
Для нахождения интеграла необходимо пройти от a до b с некоторым шагом h, и прибавлять к сумме площадь прямоугольника со сторонами f(x) и h.
#include #include int main() < double sum = 0.0; double a = 0.0; double b = 1.0; double h = 0.01; double x = a; while (x < b) < sum += x*x * h; x += h; >printf(«%.3f», sum); getch(); >
Программа выводит 0.328.
∫ 0 1 x 2 d x = x 3 3 | 0 1 = 1 3 ≈ 0.333
Если посмотреть на график, то видно, что каждый раз мы находим значение функции в левой точке. Поэтому такой метод численного интегрирования называют методом левых прямоугольников. Аналогично, можно взять правое значение. Тогда это будет метод правых прямоугольников.
while (x
Сумма в этом случае будет равна 0.338. Метод левых и правых прямоугольников не очень точен. Мы фактически аппроксимировали (приблизили) гладкий график монотонно возрастающей функции гистограммой. Если немного подумать, то аппроксимацию можно проводить не только суммируя прямоугольники, но и суммируя трапеции.
Приближение с помощью трапеций на самом деле является кусочной аппроксимацией кривыми первого порядка (ax+b). Мы соединяем точки на графике с помощью отрезков. Можно усложнить, соединяя точки не отрезками, а кусками параболы, тогда это будет метод Симпсона. Если ещё усложнить, то придём к сплайн интерполяции, но это уже другой, очень долгий разговор.
Вернёмся к нашим баранам. Рассмотрим 4 цикла.
int i = 0; while ( i++
int i = 0; while ( ++i
int i = 0; do < printf(«%d «, i); >while(i++ < 3);
int i = 0; do < printf(«%d «, i); >while(++i < 3);
Если выполнить эти примеры, то будет видно, что циклы выполняются от двух, до четырёх раз. На это стоит обратить внимание, потому что неверное изменение счётчика цикла часто приводит к ошибкам.
Часто случается, что нам необходимо выйти из цикла, не дожидаясь, пока будет поднят какой-то флаг, или значение переменной изменится. Для этих целей служит оператор break, который заставляет программу выйти из текущего цикла.
Давайте решим простую задачу. Пользователь вводит числа до тех пор, пока не будет введено число 0, после этого выводит самое большое из введённых. Здесь есть одна загвоздка. Сколько чисел введёт пользователь не известно. Поэтому мы создадим бесконечный цикл, а выходить из него будем с помощью оператора break.
Внутри цикла мы будем получать от пользователя данные и выбирать максимальное число.
#include #include int main() < int num = 0; int max = num; printf(«To quit, enter 0n»); /*бесконечный цикл*/ while (1) < printf(«Please, enter number: «); scanf(«%d», /*условие выхода из цикла*/ if (num == 0) < break; >if (num > max) < max = num; >> printf(«max number was %d», max); getch(); >
Напомню, что в си нет специального булевого типа. Вместо него используются числа. Ноль — это ложь, все остальные значения – это истина. Цикл while(1) будет выполняться бесконечно. Единственной точкой выхода из него является условие
if (num == 0)
В этом случае мы выходим из цикла с помощью break; Для начала в качестве максимального задаём 0. Пользователь вводит число, после чего мы проверяем, ноль это или нет. Если это не ноль, то сравниваем его с текущим максимальным.
Бесконечные циклы используются достаточно часто, так как не всегда заранее известны входные данные, либо они могут меняться во время работы программы.
Когда нам необходимо пропустить тело цикла, но при этом продолжить выполнение цикла, используется оператор continue. Простой пример: пользователь вводит десять чисел. Найти сумму всех положительных чисел, которые он ввёл.
#include #include int main() < int i = 0; int positiveCnt = 0; float sum = 0.0f; float input; printf(«Enter 10 numbersn»); while (i < 10) < i++; printf(«%2d: «, i); scanf(«%f», if (input sum += input; positiveCnt++; > printf(«Sum of %d positive numbers = %f», positiveCnt, sum); getch(); >
Пример кажется несколько притянутым за уши, хотя в общем он отражает смысл оператора continue. В этом примере переменная positiveCnt является счётчиком положительных чисел, sum сумма, а input — временная переменная для ввода чисел.
Вот ещё один пример. Необходимо, чтобы пользователь ввёл целое число больше нуля и меньше 100. Пока необходимое число не будет введено, программа будет продолжать опрос.
do < printf(«Please, enter number: «); scanf(«%d», if (n < 0 || n>100) < printf(«bad number, try againn»); continue; >else < break; >> while (1);
Цикл for
О дним из самых используемых является цикл со счётчиком for. Его синтаксис
Например, выведем квадраты первых ста чисел.
int i; for (i = 1; i
Одним из замечательных моментов цикла for является то, что он может работать не только с целыми числами.
float num; for (num = 5.3f; num > 0f; num -= 0.2)
Этот цикл выведет числа от 5.3 до 0.1. Цикл for может не иметь некоторых «блоков» кода, например, может отсутствовать инициализация, проверка (тогда цикл становится бесконечным) или изменение счётчика. Вот пример с интегралом, реализованный с применением счётчика for
#include #include int main() < double sum = 0.0; double a = 0.0; double b = 1.0; double h = 0.01; double x; for (x = a; x < b; x += h) < sum += x*x * h; >printf(«%.3f», sum); getch(); >
Давайте рассмотрим кусок кода
double x ; for (x = a; x
Его можно изменить так
double x = a; for (; x
Более того, используя оператор break, можно убрать условие и написать
double x; for (x = a;; x += h)< if (x>b) < break; >sum += x*x*h; >
double x = a; for (;;) < if (x >b) < break; >sum += x*x*h; x += h; >
кроме того, используя оператор «,», можно часть действий перенести
double x ; for (x = a; x < b; x += h, sum += x*x*h) ;
ЗАМЕЧАНИЕ: несмотря на то, что так можно делать, пожалуйста, не делайте так! Это ухудшает читаемость кода и приводит к трудноуловимым ошибкам.
Давайте решим какую-нибудь практическую задачу посложнее. Пусть у нас имеется функция f(x). Найдём максимум её производной на отрезке. Как найти производную функции численно? Очевидно, по определению).
Производная функции в точке — это тангенс угла наклона касательной.
f x ′ = d x d y
Возьмём точку на кривой с координатами (x; f(x)), сдвинемся на шаг h вперёд, получим точку (x+h, f(x+h)), тогда производная будет
d x d y = f ( x + h ) — f x ( x + h — x ) = tg α
То есть, отношение малого приращения функции к малому приращению аргумента. Внимательный читатель может задать вопрос, почему мы двигаемся вперёд по функции, а не назад. Ну пойдёмте назад
Возьмём среднее от этих двух значений, получим
В общем-то теперь задача становится тривиальной: идём от точки a до точки b и находим минимальное значение производной, а также точку, в которой производная принимает это значение. Для решения нам понадобятся, как и в задаче с интегралом, переменные для границ области поиска a и b, текущее значение x и шаг h. Кроме того, необходимо максимальное значение maxVal и координата maxX этого максимального значения. Для работы возьмём функцию x • sin x
#include #include #include int main() < double a = 0; double b = 3.0; double h = 0.001; double h2 = h * 2.0; double maxVal = a*sin(a); double maxX = a; double curVal; double x; // Проходим по всей области от a до b // и ищем максимум первой производной // Используем функцию x*sin(x) for (x = a; x < b; x += h) < curVal = ( (x+h)*sin(x+h)-(x-h)*sin(x-h) )/h2; if (curVal >maxVal) < maxVal = curVal; maxX = x; >> printf(«max value = %.3f at %.3f», maxVal, maxX); getch(); >
На выходе программа выдаёт max value = 1.391 at 1.077
Численное решение даёт такие же (с точностью до погрешности) результаты, что и наша программа.
Вложенные циклы
Рассмотрим пример, где циклы вложены друг в друга. Выведем таблицу умножения.
#include #include #include int main() < int i, j; // Для каждого i for (i = 1; i < 11; i++) < // Выводим строку из произведения i на j for (j = 1; j < 11; j++) < printf(«%4d», i*j); >// После чего переходим на новую строку printf(«n»); > getch(); >
В этом примере в первый цикл по переменной i вложен второй цикл по переменной j. Последовательность действий такая: сначала мы входим в цикл по i, после этого для текущего i 10 раз подряд осуществляется вывод чисел. После этого необходимо перейти на новую строку. Теперь давайте выведем только элементы под главной диагональю
for (i = 1; i < 11; i++) < for (j = 1; j < 11; j++) < if (j >i) < break; >printf(«%4d», i*j); > printf(«n»); >
Как вы видите, оператор break позволяет выйти только из текущего цикла. Этот пример может быть переписан следующим образом
for (i = 1; i < 11; i++) < for (j = 1; j printf(«n»); >
В данном случае мы используем во вложенном цикле счётчик первого цикла.
Всё ещё не понятно? – пиши вопросы на ящик
Источник: learnc.info
Операторы итерации — for , foreach , do и while
Операторы итерации многократно выполняют инструкцию или блок инструкций. Оператор for выполняет свой текст, в то время как указанное логическое выражение принимает значение true . Оператор foreach перечисляет элементы коллекции и выполняет ее текст для каждого элемента коллекции. Оператор do условно выполняет свой текст один или несколько раз. Оператор while условно выполняет свой текст ноль или более раз.
В любой момент в теле оператора итерации можно вырваться из цикла с помощью break оператора . Вы можете перейти к следующей итерации в цикле continue с помощью оператора .
Инструкция for
Оператор for выполняет оператор или блок операторов, пока определенное логическое выражение равно значению true . В следующем примере показана инструкция for , выполняющая тело пока целочисленный счетчик меньше трех:
for (int i = 0; i < 3; i++) < Console.Write(i); >// Output: // 012
В предыдущем примере показаны элементы оператора for :
-
Раздел инициализатора, который выполняется только один раз перед входом в цикл. Как правило, в этом разделе объявляется и инициализируется локальная переменная цикла. Доступ к объявленной переменной извне оператора for невозможен. В разделе инициализатора в предыдущем примере объявляется и инициализируется целочисленная переменная-счетчик:
int i = 0
Раздел итератора может содержать ноль или более следующих выражений оператора, разделенных запятыми:
- префиксное или постфиксное выражение приращения, такое как ++i или i++
- префиксное или постфиксное выражение декремента, такое как —i или i—
- присваивание
- вызов метода
- Выражение
- создание объекта с помощью new оператора
Если переменная цикла не объявлена в разделе инициализатора, в разделе инициализатора можно также использовать ноль или более выражений из предыдущего списка. В следующем примере показано несколько менее распространенных вариантов использования разделов инициализатора и итератора: присваивание значения внешней переменной цикла в разделе инициализатора, вызов метода в разделах инициализатора и итератора и изменение значения двух переменных в разделе итератора.
int i; int j = 3; for (i = 0, Console.WriteLine($»Start: i=, j=»); i < j; i++, j—, Console.WriteLine($»Step: i=, j=»)) < //. >// Output: // Start: i=0, j=3 // Step: i=1, j=2 // Step: i=2, j=1
Все разделы оператора for необязательны. Например, в следующем коде определяется бесконечный цикл for :
Инструкция foreach
Оператор foreach выполняет оператор или блок операторов для каждого элемента в экземпляре типа, который реализует интерфейс System.Collections.IEnumerable или System.Collections.Generic.IEnumerable , как показано в следующем примере.
var fibNumbers = new List < 0, 1, 1, 2, 3, 5, 8, 13 >; foreach (int element in fibNumbers) < Console.Write($»»); > // Output: // 0 1 1 2 3 5 8 13
Оператор foreach не ограничен этими типами. Его можно использовать с экземпляром любого типа, который удовлетворяет следующим условиям:
- Тип имеет открытый метод без параметров GetEnumerator . Начиная с C# 9.0 метод GetEnumerator может быть методом расширения типа.
- тип возвращаемого значения метода GetEnumerator должен содержать открытое свойство Current и открытый метод MoveNext без параметров с типом возвращаемого значения bool .
В следующем примере показано использование оператора foreach с экземпляром типа System.Span , который не реализует интерфейс:
Span numbers = new int[] < 3, 14, 15, 92, 6 >; foreach (int number in numbers) < Console.Write($»»); > // Output: // 3 14 15 92 6
Если свойство перечислителя Current возвращает возвращаемое значение ссылки ( ref T где T — это тип элемента коллекции), можно объявить переменную итерации с модификатором ref или ref readonly , как показано в следующем примере:
Span storage = stackalloc int[10]; int num = 0; foreach (ref int item in storage) < item = num++; >foreach (ref readonly var item in storage) < Console.Write($»»); > // Output: // 0 1 2 3 4 5 6 7 8 9
Если исходная коллекция инструкции foreach пуста, тело оператора foreach не выполняется и пропускается. Если оператор foreach применяется к null , возникает исключение NullReferenceException.
await foreach
await foreach (var item in GenerateSequenceAsync())
Оператор await foreach можно также использовать с экземпляром любого типа, который удовлетворяет следующим условиям:
- Тип имеет открытый метод без параметров GetAsyncEnumerator . Этот метод может быть методом расширения типа.
- Тип возвращаемого значения метода GetAsyncEnumerator имеет открытое свойство Current и открытый метод без параметров MoveNextAsync , тип возвращаемого значения которого — Task , ValueTask или любой другой подтверждающий ожидание тип, метод ожидания которого GetResult возвращает значение bool .
Элементы потока по умолчанию обрабатываются в захваченном контексте. Чтобы отключить захват контекста, используйте метод расширения TaskAsyncEnumerableExtensions.ConfigureAwait. Дополнительные сведения о контекстах синхронизации и захвате текущего контекста см. в статье Использование асинхронного шаблона, основанного на задачах. Дополнительные сведения об асинхронных потоках см. в руководстве по асинхронным потокам.
Тип переменной итерации
Можно использовать ключевое слово var , чтобы компилятор мог определить тип переменной итерации в операторе foreach , как показано в следующем коде:
foreach (var item in collection)
Можно также явно указать тип переменной итерации, как показано в следующем коде:
IEnumerable collection = new T[5]; foreach (V item in collection)
В предыдущей форме тип T элемента коллекции должен быть неявно или явно преобразован в тип V переменной итерации. Если явное преобразование из T в V завершается ошибкой во время выполнения, оператор foreach выдает исключение InvalidCastException. Например, если T является незапечатанным типом класса, V может быть любым типом интерфейса, даже тем, который T не реализует. Во время выполнения тип элемента коллекции может быть производным от T и фактически реализовать V . В противном случае возникает InvalidCastException.
Инструкция do
Оператор do выполняет оператор или блок операторов, пока определенное логическое выражение равно значению true . Так как это выражение оценивается после каждого выполнения цикла, цикл do выполняется один или несколько раз. Цикл do отличается от while цикла, который выполняется ноль или более раз.
В следующем примере показано применение оператора do .
int n = 0; do < Console.Write(n); n++; >while (n < 5); // Output: // 01234
Инструкция while
Оператор while выполняет оператор или блок операторов, пока определенное логическое выражение равно значению true . Так как это выражение оценивается перед каждым выполнением цикла, цикл while выполняется ноль или несколько раз. Цикл while отличается от do цикла, который выполняется один или несколько раз.
В следующем примере показано применение оператора while .
int n = 0; while (n < 5) < Console.Write(n); n++; >// Output: // 01234
Спецификация языка C#
Дополнительные сведения см. в следующих разделах статьи Спецификация языка C#:
Дополнительные сведения о функциях, добавленных в C# 8.0 и более поздние версии, см. в следующих заметках о функциях.
- Асинхронные потоки (C# 8.0)
- Поддержка расширения GetEnumerator для циклов foreach (C# 9.0)
См. также
- справочник по C#
- Использование оператора foreach с массивами
- Итераторы
Источник: learn.microsoft.com
Примеры программ с циклами
Циклы позволяют выполняет некоторый набор инструкций множество раз, пока соблюдается определенное условие. В языке C++ имеются следующие виды циклов:
Цикл while
Цикл while выполняет некоторый код, пока его условие истинно, то есть возвращает true. Он имеет следующее формальное определение:
while(условие) < // выполняемые действия >
После ключевого слова while в скобках идет условное выражение, которое возвращает true или false. Затем в фигурных скобках идет набор инструкций, которые составляют тело цикла. И пока условие возвращает true, будут выполняться инструкции в теле цикла.
Например, выведем квадраты чисел от 1 до 9:
#include int main() < int i ; while(i < 10) < std::cout 1 * 1 = 1 2 * 2 = 4 3 * 3 = 9 4 * 4 = 16 5 * 5 = 25 6 * 6 = 36 7 * 7 = 49 8 * 8 = 64 9 * 9 = 81
Каждый отдельный проход цикла называется итерацией. То есть в примере выше было 9 итераций.
Если цикл содержит одну инструкцию, то фигурные скобки можно опустить:
int i <>; while(++i < 10) std::cout for (инициализатор; условие; итерация) < // тело цикла >
- инициализатор выполняется один раз при начале выполнения цикла и представляет установку начальных условий, как правило, это инициализация счетчиков — специальных переменных, которые используются для контроля за циклом.
- условие представляет условие, при соблюдении которого выполняется цикл. Как правило, в качестве условия используется операция сравнения, и если она возвращает ненулевое значение (то есть условие истинно), то выполняется тело цикла, а затем выполняется итерация .
- итерация выполняется после каждого завершения блока цикла и задает изменение параметров цикла. Обычно здесь происходит увеличение счетчиков цикла.
Например, перепишем программу по выводу квадратов чисел с помощью цикла for:
#include int main() < for(int i ; i < 10; i++) < std::cout 1 * 1 = 1 2 * 2 = 4 3 * 3 = 9 4 * 4 = 16 5 * 5 = 25 6 * 6 = 36 7 * 7 = 49 8 * 8 = 64 9 * 9 = 81
Необязательно указывать все три выражения в определении цикла, мы можем одно или даже все из них опустить:
int i ; for(; i < 10;) < std::cout #include int main() < int sum <>; for (unsigned i <>; i < 6; sum += i++); std::cout
Здесь для хранения суммы чисел определена переменная sum , которая по умолчанию равна 0. В цикле определяем переменную-счетчик i и выполняем цикл, пока i не станет равна 6.
Обратите внимание на третью часть определения цикла — sum += i++ . Здесь мы прибавляем к переменной sum значение переменной i и потом увеличиваем значение i. Таким образом, мы нашли сумму чисел, но при этом обошлись без тела цикла.
Выражение инициализации может определять больше одной переменной. Например, определим две переменных и выведем на консоль их произведение:
#include int main() < int numbers[]; int sum <>; for (int i , j ; i < 6 || j < 10; i++, j++) < std::cout 1*5=5 2*6=12 3*7=21 4*8=32 5*9=45
Перебор значений в стиле for-each
Существует также особая форма цикла for , которая предназначена специально для работы с последовательностями значений. Эта форма имеет следующее формальное определение:
for(тип переменная : последовательность)
#include int main() < for (int n : ) < std::cout >
Здесь выражение как раз представляет последовательность значений — чисел int. Цикл перебирает всю эту последовательность и помещает каждое значение в переменную n , значение которой выводится на консоль.
Другой пример. Строка фактически представляет собой последовательность символов, которую также можно перебрать с помощью данной вида циклов:
#include int main() < for (char c : «Hello») < std::cout >
Здесь каждый символ строки помещается в переменную c, значение которой затем выводится на консоль.
В дальнейшем мы рассмотрим различные виды последовательности, которые можно перебирать с помощью данного вида циклов.
Цикл do
В цикле do сначала выполняется код цикла, а потом происходит проверка условия в инструкции while. И пока это условие истинно, то есть не равно 0, то цикл повторяется. Формальное определение цикла:
do < инструкции >while(условие);
#include int main() < int i ; do < std::cout while(i>0); >
Здесь код цикла сработает 6 раз, пока i не станет равным нулю.
Но важно отметить, что цикл do гарантирует хотя бы однократное выполнение действий, даже если условие в инструкции while не будет истинно. То есть мы можем написать:
int i ; do < std::cout while(i>0); >
Хотя у нас переменная i меньше 0, цикл все равно один раз выполнится.
Рассмотрим еще пример. В ряде консольных программ также реализован подобный цикл, который срабатывает, пока пользователь не введет какой-либо символ. Допустим, пользователь вводит числа, и программа должна вычислить среднее арифметическое чисел. И пусть пользователь может ввести неопределенное количество чисел, а если он захочет завершить ввод чисел, пусть введет символ «y» или «Y»:
#include int main() < char reply <>; // ответ пользователя int count <>; // количество введенных чисел double number <>; // для ввода числа double total <>; // общая сумма чисел do < std::cout > number; // Вводим число total += number; // прибавляем к совокупному числу ++count; // увеличиваем количество введенных чисел на 1 std::cout > reply; // считываем ответ пользователя > while (reply != ‘y’ reply != ‘Y’); // пока пользователь не введет символ y и Y std::cout << «The average value is » << total/count
В данном случае считываем каждое число в переменную number, а затем прибавляем ее к переменной total, попутно увеличиваем счетчик чисел — count. После каждого ввода также ожидаем еще один ввод — если пользователь введет «y» или «Y», завершаем цикл и выводим среднее арифметическое чисел. Пример работы программы:
Enter a number: 6 Finish? (y/n): n Enter a number: 5 Finish? (y/n): y The average value is 5.5
Вложенные циклы for
Можно определять вложенные циклы. Например, выведем таблицу умножения с помощью вложенного цикла for :
#include int main() < for (int i ; i < 10; i++) < for(int j ; j < 10; j++) < std::cout std::cout >
1 2 3 4 5 6 7 8 9 2 4 6 8 10 12 14 16 18 3 6 9 12 15 18 21 24 27 4 8 12 16 20 24 28 32 36 5 10 15 20 25 30 35 40 45 6 12 18 24 30 36 42 48 54 7 14 21 28 35 42 49 56 63 8 16 24 32 40 48 56 64 72 9 18 27 36 45 54 63 72 81
Операторы continue и break
Иногда возникает необходимость выйти из цикла до его завершения. В этом случае можно воспользоваться оператором break . Например, нам надо подсчитать сумму чисел от 1 до 9, пока она не станет больше 20:
#include int main() < int result<>; for(int i; i < 10; i++) < result += i; std::cout 20) break; > >
Здесь когда значение переменной result станет больше 20 (то есть когда i будет равно 6), осуществляется выход из цикла с помощью оператора break :
1 3 6 10 15 21
В отличие от оператора break , оператор continue производит переход к следующей итерации. Например, нам надо посчитать сумму только нечетных чисел из некоторого диапазона:
#include int main() < int result <>; for (int i ; i std::cout // бесконченый цикл for — условие завершения отсутствует for (;;) < >// бесконченый цикл while — условие всегда равно true while (true) < >// бесконченый цикл do-while — условие всегда равно true do < >while (true);
Однако в этих случаях в зависимости от ситуации все равно может быть какое-то условие, при котором цикл может завершить работу. В этом случае для выхода из цикла может применяться оператор break . Например, пусть пользователь бесконечно может вводить числа, а программа выводит ему квадрат числа. Но если пользователь ввел 0, то выполним выход из цикла:
#include int main() < int n <>; // для ввода числа // бесконечный цикл while(true) < std::cout > n; // Вводим число // если пользователь ввел 0, то выходим из цикла if(n == 0) break; // иначе выводим квадрат числа std::cout >
Источник: metanit.com