Циклы for язык с
Циклы используются для многократного повторения кусков кода. Возможность повторения определенных фрагментов кода – это одна из основных и в тоже время важных задач, которые приходится решать программисту. Большинство программ или сайтов используют циклы, например – для вывода новостной информации или объявлений. То есть в таких задачах необходимо выполнять постоянно операции чтения и записи, и для того чтобы не дублировать один и тот же код на помощь приходят циклы. Циклы достаточно просто объявляются в коде, однако они выполняют сложные задачи, всего лишь простым повторением.
Чтобы приступить к изучению циклов, убедитесь в том, что вы хорошо понимаете концепцию истинных и ложных значений в языке программирования Си. Потому как это будет жизненно необходимо в использовании циклов, ведь в циклах также как и в операторах выбора присутствуют условные выражения. В языке Си существует три типа циклов: for, while, do while. Каждый из них имеет свои конкретные применения. Все они описаны ниже.
Самый часто используемый цикл – это цикл for, его структура показана ниже:
for ( /*инициализация переменной; условие; изменение значения переменной*/ ) { // тело цикла (тут находится код который будет повторяться) }
Инициализация переменной позволяет либо объявить переменную и присвоить ей значение либо присвоить значение уже существующей переменной. Во-вторых, значение этой переменной сообщает программе – истинно или ложно условие цикла. И пока условие цикла – истинно, цикл должен продолжать повторяться. Управляющую переменную обязательно необходимо как-то изменять, иначе цикл будет бесконечный, например можно обновлять её так: i++, i = i + 2 или даже так i = random(5). Обратите внимание, что каждую секцию в заголовке цикла, отделяет точка с запятой , что очень важно. Также отметим, что каждый из разделов может быть пустым, хотя точки с запятой все еще должны быть там. Если условие не пустое, то оно оценивается как истинное и цикл будет выполняться до тех пор, пока что-то не сделает условие цикла – ложным. Давайте рассмотрим простой пример использования цикла for.
#include <stdio.h> int main() { int i; /* Цикл будет работать до тех пор, пока i < 10, при этом после каждой итерации переменная i будет инкрементироваться(увеличиваться на 1)*/ for ( i = 0; i < 10; i++ ) { /* Имейте ввиду что условие проверяется перед каждым повторением, то есть работа цикла остановится когда переменная i будет равна 10*/ f( “%dn”, i ); } getchar(); }
Собственно, результат работы программы:
Эта программа представляет собой очень простой пример использования цикла. переменной i присваивается ноль, и пока i меньше 10 на экран печатается значения переменной i, после этого к переменной i прибавляется единица и все снова повторяется до тех пор, пока условие не станет ложным. Имейте в виду, что значение переменной i увеличивается после выполнения кода в теле цикла запускается в первый раз.
Цикл while – очень простой цикл, вот его структура:
while ( /*условие*/ ) { // тело цикл – тут находится код, который необходимо повторять }
Тело цикла начинает выполняться, если условие цикла – истинно. Условие представляет собой логическое выражение, например х == 1 или х! = 7 (х не равно 7). То есть условие может быть абсолютно любым – любое сочетание логических выражений. Вот пример составного условия – x == 3 || x > 10, это условие будет истинным, если икс будет равен трем или икс будет больше 10. Обратите внимание, что while имеет раздела инициализации или раздела изменения управляемой переменной, поэтому перед использованием этого цикла, сначала необходимо объявить переменную, которая будет проверяться в условии цикла и в теле цикла изменять значение этой переменной. Собственно, давайте рассмотрим простой пример с использованием цикла while:
#include <stdio.h> int main() { int var = 0; /* обязательно сначала объявляем переменную */ while ( var < 10 ) { /* пока значение переменной var меньше 10 */ f( “%dn”, var ); var++; /* обновляем значение в переменной var(если этого не делать, то условие цикла всегда будет истинным, тогда цикл будет – бесконечным) */ } getchar(); }
Вот мы и рассмотрели еще один пример использования циклов, и как видите и в этом примере нет ничего сложного. Просто представьте себе, что цикл всегда начинает повторять код, который находится в теле цикла. Как только выполняется последний оператор в теле цикла, выполняется проверка условия цикла. Если условие все ещё – истинное, то цикл продолжает и дальше работать, а если условие – ложное, то выполняется выход из цикла.
Есть еще один тип циклов – do while. Этот цикл полезен, когда необходимо выполнить код по крайней мере – 1 раз. Рассмотрим его структуру:
do { // тело цикла } while ( /*условие*/ );
Структура очень простая, как видите условие находится в конце цикла ,соответственно и проверка условия будет выполняться после того, как выполнятся код в теле цикла. Обратите внимание, что условие проверяется в конце цикла, а не в начале, так что блок кода в теле цикла будет выполнен по крайней мере один раз. Если условие истинно, цикл прыгает обратно в начало и снова выполняет его. Цикл do while почти ничем не отличается от цикла while, за исключением того, что тело цикла гарантированно выполняется хотя бы один раз. Цикл while сначала проверяет условие, а потом выполняет блок кода в теле, конечно же, если условие – истинно, В то время как do while сначала выполняет код в теле цикла, а затем проверяет условие, и если оно – истинное, то он продолжает работать. Пример работы цикла do while показан ниже:
#include <stdio.h> int main() { int i = 0; do { /* Напечатает сообщение и завершит работу*/ f( “Привет! Я цикл do whilen” ); } while ( i != 0 ); getchar(); }
Обратите внимание на точку с запятой в конце цикла, вы всегда должны ставить эту точку с запятой так, как в приведенном выше примере. Очень часто эта точка с запятой не ставится, в результате – появляется ошибка компиляции. Только этот цикл заканчивается точкой с запятой, у остальных циклов в конце, кроме закрывающей скобочки – ничего не ставится. Обратите внимание, что в примере выше, этот цикл будет выполняться один раз, потому что сначала печатается сообщение а потом проверяется условие цикла.
Операторы break и continue
Эти два ключевых слова очень важны для циклов, они могут управлять повторениями в цикле. Оператор break делает принудительный выход из цикла, даже когда условие цикла – истинно. Оператор break удобно использовать, когда необходимо выйти из цикла при особых обстоятельствах. Оператор continue нужен если необходимо пропустить какой-то блок кода, но при этом не прекращать работу цикла. Подробно об операторах вы можете прочитать в разделе С++: статья про оператор continue, статья про оператор break.
Источник
Цикл – многократное прохождение по одному и тому же коду программы. Циклы необходимы программисту для многократного выполнения одного и того же кода, пока истинно какое-то условие. Если условие всегда истинно, то такой цикл называется бесконечным, у такого цикла нет точки выхода.
В языке программирования С++ существуют такие циклы:
- цикл for
- цикл while
- цикл do while
Тело цикла будет выполняться до тех пор, пока условие будет истинно(т. е. true).
// форма записи оператора цикла for: for (/*выражение1*/; /*выражение2*/; /*выражение3*/ ) { /*один оператор или блок операторов*/; }
Если в теле цикла for должен выполнится один оператор, тогда фигурные скобки можно опустить:
for (/*выражение1*/; /*выражение2*/; /*выражение3*/) /*один оператор*/;
Рассмотрим подробно три выражения записанные в круглых скобках цикла for. Выражение 1 – объявление (и) или инициализация, ранее объявленной, переменной-счетчика, которая будет отвечать за истинность условия в цикле for. Пример:
int counter = 0; // отсюда видно, что была объявлена переменная counter типа int и инициализирована значением 0
Переменная-счетчик всегда должна иметь целочисленный тип данных. Если переменная была объявлена в цикле (все равно в каком), по завершении цикла эта переменная будет уничтожена.
Разница между объявлением и инициализацией переменной:
counter; // объявление переменой count counter = 9; // инициализация целочисленной переменой count значением 9.
Выражение 2 – это условие продолжения цикла for, оно проверяется на истинность.
counter < 10; // условие истинно пока count строго меньше десяти!
Выражение 3 изменяет значение переменной-счетчика. Без выражения 3 цикл считается бесконечным, так как изменение содержимого переменной count выполняться не будет, и если изначально условие было истинным, то цикл будет бесконечным, иначе программа даже не войдет в цикл. Выражения 1, 2, 3 отделяются друг от друга обязательными разделителями, точкой с запятой. Тело цикла обрамляется фигурными скобочками, если тело цикла состоит из одного оператора ,то фигурные скобочки не нужны. Под изменением значения переменной подразумевается уменьшение или приращение значения , например:
for ( int counter = 0; counter < 15; counter++) // выполняется приращение переменной counter с шагом 1 от 0 до 15
- ++ это операция инкремента, увеличение значения переменной на единицу;
- — это операция декремента, уменьшение значения переменной на единицу.
Очень часто неправильно интерпретируется запись пределов в цикле for, в нашем случае приращение переменной counter выполняется с шагом 1 от 0 до 15. Обратите внимание на конечный предел. В условии продолжения цикла стоит знак отношения строго меньше, а значит, когда значение в переменной counter будет равно 14, выполнится выход из цикла. Ниже показан пример работы программы (см. Рисунок 1).
// for.cpp: определяет точку входа для консольного приложения. #include “stdafx.h” #include <iostream> using namespace std; int main(int argc, char* argv[]) { for (int counter = 0; counter < 15; counter ++ ) // начало цикла cout << ” ” << counter; // тело цикла cout << endl; system(“pause”); return 0; }
В строках 9, 10 записан цикл for, причём без фигурных скобочек. А раз отсутствуют фигурные скобочки, значит, телом цикла является следующий оператор, после заголовка цикла, в нашем случае – это оператор вывода:
cout << ” ” << counter; // тело цикла
Заголовком цикла for является строка 9:
for (int counter = 0; counter < 15; counter ++ ) // заголовок цикла
Фигурные скобочки можно не опускать, это кому как удобно. Но в данном случае без фигурных скобочек запись кода более компактна, чем со скобочками.
Рисунок 1 – Цикл for в С++
for ( int counter = 14; counter >= 0; counter –) // декремент переменной counter от 14 до 0 включительно
Ниже показан результат работы программы с использованием декремента, для уменьшения значения переменой-счетчика (см. Рисунок 2).
// for_dec.cpp: определяет точку входа для консольного приложения. #include “stdafx.h” #include <iostream> using namespace std; int main(int argc, char* argv[]) { for (int count = 14; count >= 0; count –) // заголовок цикла cout << ” ” << count; // тело цикла cout << endl; system(“pause”); return 0; }
В заголовке цикла for в условии продолжения цикла мы использовали нестрогий знак отношения >=, чтобы последним значением переменой-счётчика был 0.
Рисунок 2 – Цикл for в С++
Шаг в цикле for может быть отличным от единицы, а точнее, любым целым числом.
for ( int counter = 0; counter <= 20; counter += 5) // приращение переменной counter от 0 до 20 включительно с шагом 5
В этом случае переменная counter будет равняться 5, 10, 15, и 20, после чего выполнится выход из цикла for.
for ( int counter = 20; counter >= 0; counter -= 5) // изменение переменной counter от 20 до 0 включительно с шагом 5
Далее показан код программы, которая подсчитывает количество чётных чисел в интервале от 0 до 50 включительно.
// for_example.cpp: определяет точку входа для консольного приложения. #include “stdafx.h” #include <iostream> using namespace std; int main(int argc, char* argv[]) { int counter_even = 0; for (int count = 2; count <= 50; count += 2) // заголовок цикла counter_even ++; // подсчёт чётных чисел cout << “number of even numbers = ” << counter_even << endl; system(“pause”); return 0; }
В строке 9 объявлена и инициализирована нулём переменная для хранения количества чётных чисел. В заголовке цикла for в строке 10 переменная counter инициализирована двойкой, так как двойка – первое чётное число, начиная с 0. Шаг цикла равен двум, таким образом следующее чётное число это 4. В строке 11 переменная counter_even инкрементируется на каждом этапе цикла for. Результат работы программы показан ниже (см. Рисунок 3).
Рисунок 3 – Цикл for в С++
Источник
Обновл. 15 Сен 2020 |
Безусловно, наиболее используемым циклом в языке C++ является цикл for.
Цикл for
Цикл for в языке С++ идеален, когда известно необходимое количество итераций. Выглядит он следующим образом:
for (объявление переменных; условие; инкремент/декремент счетчика)
тело цикла;
Или, преобразуя for в эквивалентный цикл while:
{ // обратите внимание, цикл находится в блоке
объявление переменных;
while (условие)
{
тело цикла;
инкремент/декремент счетчика;
}
} // переменные, объявленные внутри цикла, выходят из области видимости здесь
Переменные, определенные внутри цикла for, имеют специальный тип области видимости: область видимости цикла. Такие переменные существуют только внутри цикла и недоступны за его пределами.
Выполнение цикла for
Цикл for в C++ выполняется в 3 шага:
Шаг №1: Объявление переменных. Как правило, здесь выполняется определение и инициализация счетчиков цикла, а точнее – одного счетчика цикла. Эта часть выполняется только один раз, когда цикл выполняется впервые.
Шаг №2: Условие. Если оно равно false, то цикл немедленно завершает свое выполнение. Если же условие равно true, то выполняется тело цикла.
Шаг №3: Инкремент/декремент счетчика цикла. Переменная увеличивается или уменьшается на единицу. После этого цикл возвращается к шагу №2.
Рассмотрим пример цикла for и разберемся детально, как он работает:
#include <iostream> int main() { for (int count = 0; count < 10; ++count) std::cout << count << ” “; return 0; } |
Сначала мы объявляем переменную count и присваиваем ей значение 0. Далее проверяется условие count < 10, а так как count равен 0, то условие 0 < 10 имеет значение true. Следовательно, выполняется тело цикла, в котором мы выводим в консоль переменную count (т.е. значение 0).
Затем выполняется выражение ++count, т.е. инкремент переменной. Затем цикл снова возвращается к проверке условия. Условие 1 < 10 имеет значение true, поэтому тело цикла выполняется опять. Выводится 1, а переменная count увеличивается уже до значения 2. Условие 2 < 10 является истинным, поэтому выводится 2, а count увеличивается до 3 и так далее.
В конце концов, count увеличивается до 10, а условие 10 < 10 является ложным, и цикл завершается. Следовательно, результат выполнения программы:
0 1 2 3 4 5 6 7 8 9
Циклы for могут быть несколько сложны для новичков, однако опытные кодеры любят их, так как эти циклы очень компактны и удобны. Для наглядности, давайте преобразуем цикл for, приведенный выше, в эквивалентный цикл while:
#include <iostream> int main() { { // внешние скобки нужны для обеспечения области видимости цикла int count = 0; while (count < 10) { std::cout << count << ” “; ++count; } } return 0; } |
Обратите внимание, внешние фигурные скобки здесь необходимы, так как переменная count выходит из области видимости при завершении цикла.
Еще примеры циклов for
Давайте, используя цикл for, напишем функцию вычисления значений в степени n:
int pow(int base, int exponent) { int total = 1; for (int count=0; count < exponent; ++count) total *= base; return total; } |
Функция возвращает значение base^exponent (число в степени n). base – это число, которое нужно возвести в степень, а exponent – это степень, в которую нужно возвести base.
Если экспонент равен 0, то цикл for выполняется 0 раз, и функция возвращает 1.
Если экспонент равен 1, то цикл for выполняется 1 раз, и функция возвращает 1 * base.
Если экспонент равен 2, то цикл for выполняется 2 раза, и функция возвращает 1 * base * base.
Хотя в большинстве циклов используется инкремент счетчика, мы также можем использовать и декремент счетчика:
#include <iostream> int main() { for (int count = 8; count >= 0; –count) std::cout << count << ” “; return 0; } |
Результат:
8 7 6 5 4 3 2 1 0
Также с каждой новой итерацией мы можем увеличить или уменьшить значение счетчика больше, чем на единицу:
#include <iostream> int main() { for (int count = 9; count >= 0; count -= 2) std::cout << count << ” “; return 0; } |
Результат:
9 7 5 3 1
Ошибка неучтенной единицы
Одна из самых больших проблем с которой приходится сталкиваться начинающим программистам в циклах for (а также и в других типах циклов) – это ошибка на единицу (или «ошибка неучтенной единицы»). Она возникает, когда цикл повторяется на 1 раз больше или на 1 раз меньше нужного количества итераций. Это обычно происходит из-за того, что в условии используется некорректный оператор сравнения (например, > вместо >= или наоборот). Как правило, эти ошибки трудно отследить, так как компилятор не будет жаловаться на них, программа будет работать, но её результаты будут неправильными.
При написании циклов for помните, что цикл будет выполняться до тех пор, пока условие является истинным. Рекомендуется тестировать циклы, используя разные значения для проверки работоспособности цикла. Хорошей практикой является проверять циклы с помощью данных ввода (чисел, символов и прочего), которые заставляют цикл выполниться 0, 1 и 2 раза. Если цикл работает исправно, значит всё ОК.
Правило: Тестируйте свои циклы, используя входные данные, которые заставляют цикл выполниться 0, 1 и 2 раза.
Пропущенные выражения в цикле
Также в циклах можно пропускать одно или сразу все выражения, например:
#include <iostream> int main() { int count = 0; for (; count < 10; ) { std::cout << count << ” “; ++count; } return 0; } |
Результат:
0 1 2 3 4 5 6 7 8 9
Инициализацию счетчика мы прописали вне тела цикла, а инкремент счетчика – внутри тела цикла. В самом операторе for мы указали только условие. Иногда бывают случаи, когда не требуется объявлять счетчик цикла (потому что у нас он уже есть) или увеличивать его (так как мы увеличиваем его каким-то другим способом).
Хоть это и не часто можно наблюдать, но в операторе for можно вообще ничего не указывать. Стоит отметить, что подобное приведет к бесконечному циклу:
for (;;)
тело цикла;
Вышеприведенный пример эквивалентен:
while (true)
тело цикла;
Объявления переменных в цикле for
Хотя в циклах for обычно используется только один счетчик, иногда могут возникать ситуации, когда нужно работать сразу с несколькими переменными. Для этого используется оператор Запятая. Например:
#include <iostream> int main() { int aaa, bbb; for (aaa = 0, bbb = 9; aaa < 10; ++aaa, –bbb) std::cout << aaa << ” ” << bbb << std::endl; return 0; } |
Этот цикл присваивает значения двум ранее объявленным переменным: aaa = 0 и bbb = 9. Только с каждой итерацией переменная aaa увеличивается на единицу, а bbb – уменьшается на единицу.
Результат выполнения программы:
0 9
1 8
2 7
3 6
4 5
5 4
6 3
7 2
8 1
9 0
Примечание: Вышеприведенный цикл можно переписать следующим образом:
#include <iostream> int main() { for (int aaa = 0, bbb = 9; aaa < 10; ++aaa, –bbb) std::cout << aaa << ” ” << bbb << std::endl; return 0; } |
В этом случае запятая в объявлении переменных является частью синтаксиса, а не использованием оператора Запятая. Но эффект идентичен.
Использование циклов for в старых версиях С++
В старых версиях C++ переменные, объявленные в цикле for, не уничтожались при завершении этого цикла. Т.е. у вас могло получиться что-то вроде следующего:
for (int count=0; count < 10; ++count) std::cout << count << ” “; // В старых версиях С++ переменная count здесь не уничтожается std::cout << “n”; std::cout << “I counted to: ” << count << “n”; // поэтому мы можем использовать count даже здесь |
Позднее это было запрещено, но вы все еще можете увидеть подобное в старом коде.
Вложенные циклы for
Подобно другим типам циклов, одни циклы for могут быть вложены в другие циклы for. В следующем примере мы разместили один for внутри другого for:
#include <iostream> int main() { for (char c = ‘a’; c <= ‘e’; ++c) // внешний цикл по буквам { std::cout << c; // сначала выводим букву for (int i = 0; i < 3; ++i) // внутренний цикл по числам std::cout << i; std::cout << ‘n’; } return 0; } |
С одной итерацией внешнего цикла выполняется три итерации внутреннего цикла. Следовательно, результат выполнения программы:
a012
b012
c012
d012
e012
Заключение
Циклы for являются наиболее часто используемыми циклами в языке C++. Несмотря на то, что их синтаксис, как правило, немного запутывает начинающих программистов, вы очень скоро к нему привыкните и ощутите всю мощь и удобство этих циклов.
Тест
Задание №1
Напишите цикл for, который выводит каждое четное число в диапазоне от 0 до 20.
Ответ №1
#include <iostream> int main() { for (int count = 0; count <= 20; count += 2) std::cout << count << std::endl; return 0; } |
Задание №2
Напишите функцию sumTo(), которая принимает целочисленный параметр с именем value и возвращает сумму всех чисел от 1 до значения value.
Например, если значением value является 5, то sumTo(5) должен возвратить 15, исходя из 1 + 2 + 3 + 4 + 5.
Подсказка: Используйте переменную вне тела цикла для хранения суммы чисел, как в примере с функцией pow() в подзаголовке «Еще примеры циклов for».
Ответ №2
int sumTo(int value) { int total(0); for (int count=1; count <= value; ++count) total += count; return total; } |
Задание №3
Что не так со следующим циклом?
// Выводим все числа от 8 до 0 for (uned int count=8; count >= 0; –count) cout << count << ” “; |
Ответ №3
Этот цикл for выполняется до тех пор, пока count >= 0. Другими словами, он работает до тех пор, пока переменная count не станет отрицательным числом. Однако, поскольку count является типа uned, то эта переменная никогда не сможет быть отрицательной. Следовательно, этот цикл бесконечный! Как правило, рекомендуется избегать использования типов uned в цикле, если на это нет веских причин.
Оценить статью:
Загрузка…
Источник