Параметр цикла for это типа
Здравствуйте. Оператор цикла с параметром используется в тех случаях, когда некоторое однообразное действие надо повторить определенное количество раз. Особенно, если это количество достаточно велико. Бывают же такие задачи, когда необходимо, например, вычислить сумму каких-либо величин, каждая из которых вычисляется по формуле. Ведь если непосредственно вычислять сумму 1 + 2 + 3 + … + 1000, то программа разрастется до невообразимых масштабов.
Оператор цикла с параметром в народе ещё называют “оператор For”, и в Pascal он бывает двух типов (второй тип смотрите ниже). Первый записывается так:
for i := N1 to N2 do
<ОПЕРАТОР>
Всё, что находится между for и do, называется заголовком цикла, после do – телом цикла. Переменная i зазывается параметром цикла и имеет порядковый тип (целые числа, логический тип, символы, перечислимый и диапазонный тип). Слова for, to и do – это служебные слова Pascal, которые использовать в своих программах для обозначения переменных нельзя. Индекс i, которым обозначаются номера действий в операторе цикла, изменяется от меньшего N1 к большему N2 (N1 ≤ N2). Первый номер N1 по значению не должен превышать второй N2, иначе цикл не запустится и ОПЕРАТОР ни разу не выполнится.
Важно помнить: ИЗМЕНЯТЬ ПАРАМЕТР ЦИКЛА i В ТЕЛЕ ЦИКЛА НЕЛЬЗЯ! — это вызовет ошибку.
Оператор цикла этого типа действует как:
— сначала индекс i приравнивается N1 – минимальному возможному значению;
— потом проверяется, не превышает ли i второго номера N2 (i ≤ N2). Если это условие выполняется, то идем на следующий пункт, иначе (то есть при i > N1) – выходим из цикла;
— выполняется ОПЕРАТОР в теле цикла;
— далее увеличивается i на 1, и повторяем со второго пункта (т.е. проверяем истинность условия i ≤ N2, выполняем оператор, увеличиваем i на 1, и т.д).
В роли начального значения N1 наиболее часто используют 1 или 0 (это зависит от задачи).
Приведем пример с вычислением упомянутой ранее суммой 1 + 2 + 3 + … + 1000 первых 1000 натуральных чисел. Поскольку нужно сложить числа от 1 до 1000 включительно, то было бы естественно изменять индекс i от 1 до 1000. Тогда на каждой итерации цикла (при каждом выполнении) искомую сумму, которую мы обозначим sum, будем увеличивать на i. Вот, что у нас получится.
Посчитать сумму первых 1000 натуральных чисел
Код Pascal
| 1 2 3 4 5 6 7 8 9 10 | var i, sum: integer; begin |
После запуска программы вы должны увидеть результат: 500500. Что делает наша программа?
2 строка. Описываем переменные i (параметр цикла) и sum (конечная сумма) как целые;
5 строка. Начальному значению суммы sum присваиваем 0. Это называется инициализация начальной переменной;
6 строка. Числа будем складывать от 1 до 1000;
7 строка. На каждой последующей итерации цикла к сумме прибавляем i;
8 строка. После выхода из цикла (когда будет i = 1000) выводим конечный результат суммы.
Решим ещё одну простенькую задачку:
Напечатать ряд чисел 20 в виде: 20 20 20 20 20 20 20 20 20 20.
Код Pascal
| 1 2 3 4 5 6 7 | var i: byte; begin |
Мы видим, что количество выводимых чисел равно 10, поэтому запускаем цикл от 1 до 10, и выводим число 20 оператором вывода write(). Обратите внимание, что величина индекса изменяется лишь в пределах [1, 10], поэтому не имеет смысла использовать целый тип integer – достаточно обойтись типом byte (8 бит, или 1 байт). Особенность этого примера в том, что код программы не содержит переменной i в теле цикла (напоминаю, тело цикла – часть программы после do) – мы просто выводили несколько раз число 20. Бывает, когда параметр цикла используется в теле цикла, но во многих простеньких программах его использование лишнее.
А вот пример простой задачи, когда параметр цикла используется:
Напечатать “столбиком” все целые числа от 12 до 25.
Если промежуточное выводимое число обозначить n, то изменяя его с 12 по 25 включительно, выведем все числа. Только здесь нужно задействовать оператор вывода writeln – с переводом курсора на следующую строку.
Код Pascal
| 1 2 3 4 5 6 7 | var n: byte; begin |
И ещё один пример:
Напечатать таблицу умножения на 7.
Код Pascal
| 1 2 3 4 5 6 7 8 | var i: byte; begin |
Вместо “крестика” (знак умножения) можете использовать что-либо другое например, клавиатурные “звездочку” или букву “x”. После запуска программы у вас должно получится так:
7 × 1 = 7
7 × 2 = 14
7 × 3 = 21
7 × 4 = 28
7 × 5 = 35
7 × 6 = 42
7 × 7 = 49
7 × 8 = 56
7 × 9 = 63
7 × 10 = 70
Если вместо ОПЕРАТОРА в теле цикла необходимо выполнить несколько операторов, то их нужно заключить в операторные скобки BEGIN … END, и разделить между собой точкой с запятой (в конце последнего оператора, перед закрывающим end, точку с запятой ставить не обязательно). Образованая таким образом конструкция из нескольких операторов называется составным оператором:
for i := N1 to N2 do
begin
<ОПЕРАТОР 1>;
<ОПЕРАТОР 2>;
<ОПЕРАТОР 3>;
…………
<ОПЕРАТОР k>
end.
Операторы в составном операторе в цикла выполняются один за другим, после чего по возможности производится переход на следующую итерацию. Наведем примеры.
Рассчитать значения y для значений х, равных 4, 5, …, 28: y = 2t2 + 5.5t – 2, если t = x + 2.
Код Pascal
| 1 2 3 4 5 6 7 8 9 10 11 12 13 | var x, t: integer; y: real; begin |
2, 3 строки. Описываем x, t как целые, а y – вещественную;
6 строка. Изменяем x в указаных в условии пределах [4, 28];
8 строка. Предварительно вычисляем t, используя значение x;
9 строка. Вычисляем y, подставляя найденное ранее t;
10 строка. Выводим значения x и y.
Синтаксис другого типа оператора цикла с параметром задается следующим образом:
for i := N1 downto N2 do
<ОПЕРАТОР>
Отличие этого цикла от первого только в том, что значение индекса i не увеличивается, а уменьшается (на это указывает английское слово down, означающе “вниз”). Таким образом, начальное значение N1 параметра цикла i должно быть НЕ МЕНЬШЕ конечного N2 (N1 ≥ N2), ибо в противном случае цикл ни разу не выполнится.
Для примера решим такую задачу:
Вычислить сумму первых 1000000 членов гармонического ряда.
Гармоническим рядом в математике называют ряд, составленный из чисел, обратных к натуральным: 1 + 1/2 + 1/3 + … + 1/n + … . По условию нужно сложить первые 1000000 (один миллион) членов, только мы это сделаем в обратоном по отношению к указанному выше порядке: 1/1000000 + 1/999999 + … + 1/3 + 1/2 + 1.
Код Pascal
| 1 2 3 4 5 6 7 8 9 10 11 | var i: integer; sum: real; begin |
А вот как эта задача решается с циклом первого типа, посмотрите на странице for 10-14. Только нужно иметь ввиду, что, хотя гармонический ряд и является расходимым – его частичные суммы стремятся к бесконечности при неограниченном возрастании членов) – но растет гармонический ряд очень медленно.
Вообще, в каждом отдельном случае нужно решать, какой цикл с параметром использовать лучше – с возрастающим или убывающим параметром. В разделе Задачника в группе “for” есть много примеров на тему цикла с параметром, например, Функции с использованием факториала. А пока на этом все, если есть вопросы или пожелания, пишите в комментариях.
Источник
Цикл с параметром. Инструкция for
Инструкция цикла for реализует алгоритмическую структуру цикл с параметром (или цикл со счетчиком). Цикл for применяется в том случае, когда в программе, прежде выполнения инструкций цикла, становится известным (или заранее определено) количество шагов этого цикла. В блок-схеме инструкция for изображается следующим образом:
Синтаксис:
for (инициализация; условие; модификация) {
Инструкции тела цикла;
}
Если в теле цикла одна инструкция, то { } можно опустить. Переменная-параметр цикла (счетчик) может быть любого числового типа. Это делает цикл for C++ таким же универсальным, как и цикл типа while. В разделе модификации чаще всего используется операция постфиксного или префиксного инкремента (или декремента), но может использоваться любое выражение с присваиванием, изменяющее значение параметра цикла. Цикл работает следующим образом:
- В начале происходит описание и инициализация переменной-счетчика
- Далее проверка условия: если выражение имеет значение true, произойдет итерация
- После выполнения инструкций тела цикла производится модификация величины счетчика
Примечание: в C++ является правилом делать описание переменной-счетчика в заголовке цикла. Но это не обязательно, тем более, если планируется инициализировать несколько переменных в разделе инициализации так, как это реализовано в программе 9.2. Однако, использование описания переменной-счетчика в заголовке цикла приводит к описанию локальной переменной, уничтожаемой автоматически при завершении работы цикла. Поэтому, без крайней необходимости, описание переменной-счетчика вне цикла for производить не следует.
В процессе работы цикла for не рекомендуется изменять операнды в выражениях заголовка цикла – это приведет к разного рода ошибкам! Но сами значения переменных (или констант), в том числе изменяемые значения (счетчик), использовать можно. Рассмотрим классический пример.
Программа 9.1 Дано натуральное число N. Вывести все делители этого числа.
#include <iostream>
using namespace std;
int main() {
int N;
cout << “N = “; cin >> N;
for (int i = 2; i < N / 2; i++) {
if (N % i == 0)
cout << i << ” “;
}
return 0;
}
N = 16000
2 4 5 8 10 16 20 25 32 40 50 64 80 100 125 128 160 200 250 320 400 500 640 800 1000 1600 2000 3200 4000
Использование инструкции continue в цикле for
При использовании инструкции continue в цикле for необходимо учитывать особенности работы этого цикла:
- Инструкции, следующие после continue, будут пропущены
- Затем происходит модификация счетчика
- Переход к выполнению следующей итерации (иначе, проверки условия)
Покажем это на примере:
int main() {
for (int i = 1; i < 20; i++) {
if (i % 2 == 0) continue;
cout << i << ” “;
}
1 3 5 7 9 11 13 15 17 19
Примечание. Обратите внимание: хотя вывод чисел по условию пропущен, но инкрементация счетчика выполняется. Этот пример приведен всего-лишь для иллюстрации, программировать цикл так не следует! Эту задачу лучше решить следующим образом:
int main() {
for (int i = 1; i < 20; i += 2)
cout << i << ” “;
Несколько выражений в разделе инициализации и модификации
Как мы уже отметили ранее в заголовке инструкции for должно быть три раздела. Выражения, находящееся в этих разделах, можно опускать, но нельзя опускать “;”. В конце концов, можно оставить только ;. Заголовок в виде:
for (;;) { … }
является заголовком “бесконечного” цикла. (Выход из цикла должен программироваться внутри тела цикла).
C++ поддерживает несколько выражений в разделах инициализации и модификации в заголовке инструкции for. При этом условие продолжения цикла должно быть одно!
Например. Постановка задачи: Вычислить факториал числа, не превосходящий 20.
Программа 9.2
#include <iostream>
using namespace std;
int main() {
unsigned long long n;
int i, k;
cout << “k = “; cin >> k; // 0 <= k <= 20
for(n = 1, i = 1; i <= k; n *= i, ++i);
cout << k << “! = ” << n << endl;
return 0;
}
k = 20
20! = 2432902008176640000
Примечание: обратите внимание, что поток вывода в строке 12 не относится к телу цикла! (В конце заголовка – ;). Таким образом, данный цикл в теле имеет пустую инструкцию, а все выражения вычисляются в заголовке. Программа 9.2 правильно вычисляет факториал числа от 0 до 20.
Цикл for основанный на диапазоне (range-based for)
Для перебора элементов массива или контейнера приходится выполнять однотипные действия, при этом использовать громоздкий код. Для упрощения работы с контейнерами в C++ существует специальная форма цикла for – range-based for (цикл for основанный на диапазоне или диапазонный for).
Синтаксис:
for (объявление : имя_последовательности)
loop_statement
Использование range-based for на примере C-массива:
Программа 9.3
#include <iostream>
using namespace std;
int main() {
int x[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
for (auto &s : x) {
cout << s << ” “;
}
return 0;
}
Чтобы элементы массива можно было изменять – переменная s должна быть ссылочной переменной (как в примере выше). Если переменная не является ссылкой, то данные будут копироваться. Для автоматического выведения типа в этом цикле используется спецификатор auto. range-based for имеет ограничение на работу с динамическими массивами: он не поддерживает изменение размера массива, так как содержит фиксированный указатель конца массива. При работе с массивами, имеющими фиксированный размер, диапазонный for является прекрасной и безопасной альтернативой обычному for.
Вложенные циклы for
Так же, как и другие инструкции циклов, for поддерживает структуру вложенных циклов. Применение вложенных циклов for для организации ввода и вывода двумерных массивов выглядит гораздо компактнее, чем при использовании цикла while.
Однако, при решении задач обхода таких массивов, необходимо избегать применение условной инструкции if. Зачастую, задачу можно реализовать более рационально, путем манипуляции индексами (переменными цикла i и j). То есть, поставить в зависимость изменение одного индекса, от значения величины другого. Рассмотрим два примера.
Программа 9.4 Дана квадратная матрица размера n, элементы которой равны 0. Заполнить элементы, лежащие ниже и на самой главной диагонали единицами.
#include <iostream>
using namespace std;
int main() {
int n;
cout << “n = “; cin >> n;
int mas[n][n];
// Заполняем нулями
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
mas[i][j] = 0;
// Реализация
for(int i = 0; i < n; i++)
for(int j = 0; j <= i; j++)
mas[i][j] = 1;
// Вывод
for(int i = 0; i < n; i++) {
for(int j = 0; j < n; j++) {
cout.width(2);
cout << mas[i][j];
}
cout << ‘n’;
}
return 0;
}
n = 10
1 0 0 0 0 0 0 0 0 0
1 1 0 0 0 0 0 0 0 0
1 1 1 0 0 0 0 0 0 0
1 1 1 1 0 0 0 0 0 0
1 1 1 1 1 0 0 0 0 0
1 1 1 1 1 1 0 0 0 0
1 1 1 1 1 1 1 0 0 0
1 1 1 1 1 1 1 1 0 0
1 1 1 1 1 1 1 1 1 0
1 1 1 1 1 1 1 1 1 1
Программа 9.5 Составить программу заполнения массива числами треугольника Паскаля и вывода этого массива. Треугольник паскаля имеет вид:
В этом треугольнике на вершине и по бокам стоят единицы (в программе 9.5 треугольник “положен на бок” – стороны треугольника: первый столбец и главная диагональ). Каждое число равно сумме двух чисел, расположенных над ним. Строки треугольника симметричны относительно вертикальной оси и содержат биноминальные коэффициенты.
#include <iostream>
using namespace std;
int main() {
int n;
cout << “n = “; cin >> n;
int pas[n][n];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
pas[i][j] = 0;
pas[0][0] = 1;
for (int i = 1; i < n; i++) {
pas[i][0] = 1;
for (int j = 1; j <= i; j++) {
pas[i][j] = pas[i – 1][j – 1] + pas[i – 1][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j <= i; j++) {
cout.width(4);
cout << pas[i][j];
}
cout << ‘n’;
}
return 0;
}
n = 12
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1
1 10 45 120 210 252 210 120 45 10 1
1 11 55 165 330 462 462 330 165 55 11 1
Вопросы
- Может ли быть заменена в программе инструкция цикла for на инструкцию цикла while? Всегда ли это можно сделать?
- Когда удобнее применять для организации циклов инструкцию for? while?
- Возможны ли в заголовке инструкции for следующие выражения:
a) for (;a > b && !(a % 2);)
b) for (a > b;;)
c) for (;;i = 0)
d) for (;i = 0;)
e) for (;;i++, –b)
f) for (–i;;)
g) for (b = 0; b != a;) ? - Переменная i – параметр внешнего цикла, а j – вложенного. Доступна ли будет переменная j во внешнем цикле? i во вложенном цикле?
Учебник
§58
Домашняя работа
- Зад. 29. Напишите программу, в которой вводятся натуральные числа a и b, а на дисплей выводятся все простые числа в диапазоне от a до b (идея алгоритма Программа 8.5)
- Зад. 30. Совершенным называется число, равное сумме всех своих делителей, меньших его самого (например, число 6 = 1 + 2 + 3). Напишите программу, которая вводит натуральное число N и определяет, является ли число N совершенным.
- Напишите программу, которая выводит на экран квадратную числовую таблицу размера n x n, имеющую следующий вид при n = 10:
1 * * * * * * * * *
* 2 * * * * * * * *
* * 3 * * * * * * *
* * * 4 * * * * * *
* * * * 5 * * * * *
* * * * * 6 * * * *
* * * * * * 7 * * *
* * * * * * * 8 * *
* * * * * * * * 9 *
* * * * * * * * * 10
Литература
- Лафоре Р. Объектно-ориентированное программирование в C++ (4-е изд.). Питер: 2004
- Прата, Стивен. Язык программирования C++. Лекции и упражнения, 6-е изд.: Пер. с англ. — М.: ООО «И.Д. Вильяме», 2012
- Липпман Б. Стенли, Жози Лажойе, Барбара Э. Му. Язык программирования С++. Базовый курс. Изд. 5-е. М: ООО “И. Д. Вильямс”, 2014
- Эллайн А. C++. От ламера до программера. СПб.: Питер, 2015
- Шилдт Г. С++: Базовый курс, 3-изд. М.: Вильямс, 2010
Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.
Источник
Обновл. 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 (unsigned int count=8; count >= 0; –count) cout << count << ” “; |
Ответ №3
Этот цикл for выполняется до тех пор, пока count >= 0. Другими словами, он работает до тех пор, пока переменная count не станет отрицательным числом. Однако, поскольку count является типа unsigned, то эта переменная никогда не сможет быть отрицательной. Следовательно, этот цикл бесконечный! Как правило, рекомендуется избегать использования типов unsigned в цикле, если на это нет веских причин.
Оценить статью:
Загрузка…
Источник