Циклы
Для выполнения некоторых действий множество раз в зависимости от определенного условия используются циклы. В языке C++ имеются следующие виды циклов:
· for
· while
· do...while
Цикл while
Цикл while выполняет некоторый код, пока его условие истинно, то есть возвращает true. Он имеет следующее формальное определение:
while(условие)
{
// выполняемые действия
}
После ключевого слова while в скобках идет условное выражение, которое возвращает true или false. Затем в фигурных скобках идет набор инструкций, которые составляют тело цикла. И пока условие возвращает true, будут выполняться инструкции в теле цикла.
Например, выведем квадраты чисел от 1 до 9:
#include <iostream>
using namespace std;
int main()
{
int i = 1;
while(i < 10)
{
cout << i << " * " << i << " = " << i * i << endl;
i++;
}
return 0;
}
Здесь пока условие i < 10 истинно, будет выполняться цикл while, в котором выводится на консоль квадрат числа и инкрементируется переменная i. В какой-то момент переменная i увеличится до 10, условие i < 10 возвратит false, и цикл завершится.
Консольный вывод программы:
Каждый отдельный проход цикла называется итерацией. То есть в примере выше было 9 итераций.
Если цикл содержит одну инструкцию, то фигурные скобки можно опустить:
int i = 0;
while(++i < 10)
cout << i << " * " << i << " = " << i * i << endl;
Часто нужно будет, чтобы цикл выполнялся определённое количество раз. Для этого обычно используется переменная в виде счётчика цикла. Счётчик цикла – это целочисленная переменная, которая объявляется с единственной целью: считать, сколько раз выполнился цикл.
Счётчикам цикла часто дают простые имена, такие как i, j или k. Однако, в этих именах есть одна серьёзная проблема. Если вы захотите узнать, где в вашей программе используется счётчик цикла и воспользуетесь функцией поиска i, j или k, то в результате получите половину своей программы, так как i, j или k используются во многих именах. Следовательно, лучше использовать iii, jjj или kkk в качестве имён для счётчиков. Они более уникальны, их значительно проще найти, и они выделяются в коде. А ещё лучше использовать «реальные» имена для переменных, например, count или любое другое имя, которое предоставляет контекст использования этой переменной.
Также для счётчиков цикла лучше использовать тип signed int. Использование unsigned int может привести к неожиданным результатам. Например:
#include <iostream>
using namespace std;
int main()
{
unsigned int count = 10;
// Считаем от 10 к 0
while (count >= 0)
{
if (count == 0)
cout << "blastoff!";
else
cout << count << " ";
--count;
}
return 0;
}
Оказывается, эта программа представляет собой бесконечный цикл. Она начинается с вывода 10 9 8 7 6 5 4 3 2 1 blastoff! как и предполагалось, но затем уходит с рельсов и начинает отсчёт с 4294967295. Почему? Потому что условие цикла count >= 0 никогда не будет ложным! Когда count = 0, то и условие 0 >= 0 имеет значение true, выводится blastoff, а затем выполняется декремент переменной count, происходит переполнение и значением переменной становится 4294967295. И так как условие 4294967295 >= 0 является истинным, то программа продолжает своё выполнение. А поскольку счётчик цикла является типа unsigned, то он никогда не сможет быть отрицательным, и поскольку он никогда не сможет быть отрицательным, то цикл никогда не завершится.
Правило: Всегда используйте тип signed int для счётчиков цикла.
Цикл for
Цикл for имеет следующее формальное определение:
for (выражение_1; выражение_2; выражение_3)
{
// тело цикла
}
выражение_1 выполняется один раз при начале выполнения цикла и представляет установку начальных условий, как правило, это инициализация счетчиков - специальных переменных, которые используются для контроля за циклом.
выражение_2 представляет условие, при соблюдении которого выполняется цикл. Как правило, в качестве условия используется операция сравнения, и если она возвращает ненулевое значение (то есть условие истинно), то выполняется тело цикла, а затем вычисляется выражение_3.
выражение_3 задает изменение параметров цикла, нередко здесь происходит увеличение счетчиков цикла на единицу.
Рассмотрим пример цикла 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:
#include <iostream>
using namespace std;
int main()
{
for(int i =1; i < 10; i++)
{
cout << i << " * " << i << " = " << i * i << endl;
}
return 0;
}
Первая часть объявления цикла - int i = 1 - создает и инициализирует счетчик i. Фактически это то же самое, что и объявление и инициализация переменной. Счетчик необязательно должен представлять тип int. Это может быть и другой числовой тип, например, float. И перед выполнением цикла его значение будет равно 1.
Вторая часть - условие, при котором будет выполняться цикл. В данном случае цикл будет выполняться, пока переменная i не станет равна 10.
И третья часть - приращение счетчика на единицу. Опять же нам необязательно увеличивать на единицу. Можно уменьшать: i--. Можно изменять на другое значение: i+=2.
В итоге блок цикла сработает 9 раз, пока переменная i не станет равна 10. И каждый раз это значение будет увеличиваться на 1. И по сути мы получим тот же самый результат, что и в случае с циклом while:
Необязательно указывать все три выражения в определении цикла, можно одно или даже все из них опустить:
int i = 1;
for(; i < 10;)
{
cout << i << " * " << i << " = " << i * i << endl;
i++;
}
Формально определение цикла осталось тем же, только теперь первое и третье выражения в определении цикла отсутствуют: for (; i < 10;). Переменная-счетчик определена и инициализирована вне цикла, а ее приращение происходит в самом цикле.
Можно определять вложенные циклы. Например, выведем таблицу умножения:
#include <iostream>
using namespace std;
int main()
{
for (int i=1; i < 10; i++)
{
for(int j = 1; j < 10; j++)
{
cout << i * j << "\t";
}
cout << endl;
}
return 0;
}
Также можно увеличивать или уменьшать значение счётчика больше, чем на единицу с каждой новой итерацией:
#include <iostream>
using namespace std;
int main()
{
for (int count = 9; count >= 0; count -= 2)
cout << count << " ";
return 0;
}
Результат:
9 7 5 3 1
Хотя в циклах for обычно используется только один счётчик, иногда могут возникать ситуации, когда нужно работать сразу с несколькими переменными. Для этого используется оператор Запятая. Например:
#include <iostream>
using namespace std;
int main()
{
int aaa, bbb;
for (aaa = 0, bbb = 9; aaa < 10; ++aaa, --bbb)
cout << aaa << " " << bbb << 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>
using namespace std;
int main()
{
for (int aaa = 0, bbb = 9; aaa < 10; ++aaa, --bbb)
cout << aaa << " " << bbb << endl;
return 0;
}
В этом случае запятая в объявлении переменных является частью синтаксиса, а не использованием оператора Запятая. Но эффект идентичен.
Подобно другим типам циклов, одни циклы for могут быть вложены в другие циклы for. В следующем примере мы разместили один for внутри другого for:
#include <iostream>
using namespace std;
int main()
{
for (char c = 'a'; c <= 'e'; ++c) // внешний цикл по буквам
{
cout << c; // сначала выводим букву
for (int i = 0; i < 3; ++i) // внутренний цикл по числам
cout << i;
cout << '\n';
}
return 0;
}
С 1 итерацией внешнего цикла выполняется 3 итерации внутреннего цикла. Следовательно, результат выполнения программы выше:
a012
b012
c012
d012
e012
Цикл do
В цикле do сначала выполняется код цикла, а потом происходит проверка условия в инструкции while. И пока это условие истинно, то есть не равно 0, то цикл повторяется. Формальное определение цикла:
do
{
инструкции
}
while(условие);
Например:
#include <iostream>
using namespace std;
int main()
{
int i = 6;
do
{
cout << i << endl;
i--;
}
while(i>0);
return 0;
}
Здесь код цикла сработает 6 раз, пока i не станет равным нулю.
Но важно отметить, что цикл do гарантирует хотя бы однократное выполнение действий, даже если условие в инструкции while не будет истинно. То есть можно написать:
int i = -1;
do
{
cout << i << endl;
i--;
}
while(i>0);
}
Хотя переменная i меньше 0, цикл все равно один раз выполнится.
Операторы continue и break
Иногда возникает необходимость выйти из цикла до его завершения. В этом случае можно воспользоваться оператором break. Например:
#include <iostream>
using namespace std;
int main()
{
int i = 1;
for (;;)
{
cout << i << " * " << i << " = " << i * i << endl;
i++;
if (i > 9) break;
}
return 0;
}
Здесь когда значение переменной i достигнет 10, осуществляется выход из цикла с помощью оператора break.
В отличие от оператора break, оператор continue производит переход к следующей итерации. Например, нам надо посчитать сумму только нечетных чисел из некоторого диапазона:
#include <iostream>
using namespace std;
int main()
{
int result = 0;
for (int i=0; i<10; i++)
{
if (i % 2 == 0) continue;
result +=i;
}
cout << "result = " << result << endl; // 25
return 0;
}
Чтобы узнать, четное ли число, мы получаем остаток от целочисленного деления на 2, и если он равен 0, то с помощью оператора continue переходим к следующей итерации цикла. А если число нечетное, то складываем его с остальными нечетными числами.