Цикл с параметром цикл 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
sum := 0; //Начальное значение суммы
for i := 1 to 1000 do
sum := sum + i; //К сумме прибавляем i
writeln(‘Результат: ‘, sum);
readln
end.

После запуска программы вы должны увидеть результат: 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
for i := 1 to 10 do write(‘ ‘, 20);
readln
end.

Мы видим, что количество выводимых чисел равно 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
for n := 12 to 25 do writeln(n);
readln
end.

И ещё один пример:

Напечатать таблицу умножения на 7.

Код Pascal

1
2
3
4
5
6
7
8

var
i: byte;

begin
for i := 1 to 10 do
writeln(‘7 × ‘, i, ‘ = ‘, 7 * i);
readln
end.

Вместо “крестика” (знак умножения) можете использовать что-либо другое например, клавиатурные “звездочку” или букву “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
for x := 4 to 28 do
begin
t := x + 2;
y := 2 * t * t + 5.5 * t – 2;
writeln(‘ x = ‘, x:2, ‘, y = ‘, y)
end;
readln
end.

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
sum := 0; //Начальное значение суммы
for i := 1000000 downto 1 do
sum := sum + 1/i; //К сумме прибавляем 1/i
writeln(‘Результат: ‘, sum);
readln
end.

А вот как эта задача решается с циклом первого типа, посмотрите на странице for 10-14. Только нужно иметь ввиду, что, хотя гармонический ряд и является расходимым – его частичные суммы стремятся к бесконечности при неограниченном возрастании членов) – но растет гармонический ряд очень медленно.

Вообще, в каждом отдельном случае нужно решать, какой цикл с параметром использовать лучше – с возрастающим или убывающим параметром. В разделе Задачника в группе “for” есть много примеров на тему цикла с параметром, например, Функции с использованием факториала. А пока на этом все, если есть вопросы или пожелания, пишите в комментариях.

Источник

Цикл с параметром был уже рассмотрен нами в разделе “Алгоритм” в теме “Виды алгоритмов”.
Цикл с параметром
используется, когда заранее известно
сколько раз должен выполниться цикл.

Формат записи цикла:

For <пар.цикла> :=
<нач.знач> to <кон.знач.> do <оператор>

Здесь for, to, do –
зарезервированные слова (для, до, выполнить);

<пар. цикла> – параметр цикла – переменная целочисленного типа (типа integer);

<нач. знач.> – начальное значение – число или переменная целочисленного типа (типа integer);

<кон. знач.> – конечное значение – число или переменная целочисленного типа (типа integer);

<оператор> – произвольный оператор Паскаля.

Пример:  For i:=1 to n do <оператор>
здесь i – параметр цикла
         1 – начальное значение
n – конечное значение
       Если в теле цикла используется несколько операторов, тогда, используются
операторные скобки: begin … end.
       При выполнении оператора for вначале вычисляется выражение <нач .знач.> и осуществляется присваивание его значения переменной цикла <пар .цикла> := <нач. знач.>. Далее сравниваются <пар .цикла> и  <кон.знач.>. До тех пор, пока они не станут равными будет выполняться оператор (операторы). Значение переменной цикла <нач.знач> автоматически увеличивается на единицу в ходе выполнения цикла. Надо сразу заметить, что задать шаг цикла, отличный от 1 в этом операторе нельзя.
Пример:
       Возможны такие записи
оператора цикла:

1) for i:= 1 to n do s1;

2) for i:= 3 to 10 do s1;

3) for i :=
a to b do s1;

4) for i := a to b do
begin

       s1;
       s2;
       …
       sn

end;

Здесь s1,
s2, s3, … sn – операторы цикла.

Пример:
Составить программу вывода на экран чисел от 1 до 10.

Блок-схема:

Программный код:
Program Problem; {Вывод чисел}
var i : integer;
   begin
for i:=1 to 10 do
  writeln (i);
redaln;
end.

Пример:
Составить программу вычисления факториала числа n, т. е. n!. (0! = 1)

Блок-схема:

Программный код:

Program Problem1; {Вычисление факториала числа n!}
var
n, f, i : integer;
   begin
   write(‘Введите натуральное число’);
   readln(n);
   f := 1;
   if n <> 0 then for i := 1 to n do f := f*i;
   writeln (‘Факториал числа ‘, n, ‘ равен ‘, f);
redaln;
end.

Объяснение
программы:
       Переменная n – для вводимого пользователем числа, факториал которого надо
найти; f – переменная, в которой будет “накапливаться” значение
факториала числа n; i – переменная цикла.
       Устанавливается первоначальное значение переменной f := 1.
       Далее начинается цикл. Переменной i присваивается начальное значение 1; оно
сравнивается с конечным – n (1 <= n), если условие
истинно, тогда выполняется оператор (в этой программе он один): f :=
f*i, 1*1=1; значение переменной цикла увеличивается на 1, т. е. станет равным:
i := i + 1, 1 + 1 = 2 и цикл повторяется.
       Когда значение i станет равным n, тогда цикл выполнится
последний раз, потому что следующее значение i будет n + 1, что больше
конечного значения n, условие i <= n – ложно, цикл не
выполняется.

Существует другая форма оператора цикла For:
Формат записи цикла:

For <пар.цикла> :=
<нач.знач> downto <кон.знач.> do <оператор>

Замена зарезервированного
слова to на downto означает, что шаг параметра цикла
равен (-1).
Изменение значения
параметра идет от большего значения к меньшему, т. е. <нач. знач.> <кон. знач.>.

Пример:
Возможны такие записи оператора цикла:

1) for i:= n downto 1 do s1;

2) for i:= 10 downto 3 do s1;

3) for i := b downto a do s1; (при условии, что b>a)

4) for i := b downto a do
begin

                    s1;
                    s2;
                   …
                 sn

end; (при условии, что b>a)

Здесь s1, s2, s3, … sn – операторы цикла.

Пример: Программу вычисления факториала числа можно составить, используя этот оператор
цикла.

Блок-схема

Программный код:
var
n, i, f : longint;
   begin
   write(“Введите натуральное число “);
   readln(n);
   f := 1;
   if n <> 0 then for i := n downto 1 do f := f*i;
   writeln(“Факториал числа “, n, ” равен “, f);
end.

Задачи

Даны 10 чисел, вывести те из них, которые являются полными квадратами. Составить блок-схему и программу.
Даны 10 чисел, найти их произведение. Составить блок-схему и программу.
Даны 10 чисел, найти сумму четных. Составить блок-схему и программу.
Даны 10 чисел, найти количество отрицательных. Составить блок-схему и программу.
Даны n действительных чисел. Найти максимум и минимум. Составить блок-схему и программу.
Даны n действительных чисел. Найти среднее арифметическое всех элементов. Составить блок-схему и программу.
Даны n действительных чисел. Найти среднее арифметическое отрицательных и положительных элементов. Составить блок-схему и программу.
Даны n натуральных чисел. Найти сумму и произведение элементов, кратных 3 и 5. Составить блок-схему и программу.
Даны n натуральных чисел. Вывести те числа, значения которых являются степенями двойки (1, 2, 4, 8, 16, …). Составить блок-схему и программу.
Даны n натуральных чисел. Вывести те числа, значения которых находятся в отрезке [a, b]. Составить блок-схему и программу.
Даны n натуральных чисел. Вывести на экран те числа, значения которых являются квадратами какого-либо числа.Составить блок-схему и программу.
Дано натуральное число n. Найти n2. Составить блок-схему и программу.
Даны натуральные числа a, n. Найти an. Составить блок-схему и программу.
Дано натуральное число n. Определить его разрядность, цифру старшего разряда числа увеличить на 2
Дано натуральное число n. Поменять местами первую и последнюю цифры числа
Дано натуральное число n. Цифры числа, кратные 2 заменить на 0.
Дано натуральное число n. Цифры числа, кратные 3 заменить на 1.
Дано натуральное число n. Вычислить произведение (2n-1)*(3n-1)*(4n-1)*…*(10n-1). Составить блок-схему и программу.
Вычислить сумму 2+4+6+…+100. Составить блок-схему и программу.
Дано натуральное число n, действительное x. Вычислить произведение x+x/2+x/3+…+x/n. Составить блок-схему и программу.
Дано натуральное число n. Вычислить P=(1-1/2)(1-1/3)…(1-1/n), где n>2. Составить блок-схему и программу.
Дано натуральное число n. Вычислить P=(1+x)/n+(2+x)/(n-1)+…+(n+x)/1. Составить блок-схему и программу.
Даны n натуральных чисел. Вычислить сумму ряда 1+x/1!+x2/2!+x3/3!+ …+xn/n!. Составить блок-схему и программу.

Наверх

Источник

Циклы чрезвычайно важны в программирования на C++, да и в остальных языках. Начнем с теории.

Цикл — это повторение одного и того же участка кода в программе. Последовательность действий, которые повторяются, называют телом цикла. Один проход цикла — это шаг или итерация. Переменные, изменяющиеся внутри цикла и влияющие на его окончание, называются параметрами цикла.

В C++ предусмотрены три оператора, реализующих циклический процесс: while, do..while и for. Рассмотрим каждый из них.

Оператор с предусловием (while)

Он работает следующим образом. Вычисляется значение выражения. Если оно истинно, то выполняется оператор. В противном случае цикл заканчивается. Если состоит более чем из одного оператора, необходимо использовать составной оператор:

while условие
{
оператор_1;
оператор_2;
…
оператор_n;
}

Рассмотрим пример. Пусть нам необходимо составить программу, которая в зависимости от возраста пользователя определяла сколько лет ему осталось до выхода на пенсию. При условии, что пенсионный возраст наступает в 56 лет.

#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;

}

Вот результат работы программы:

Цикл с параметром цикл for

Цикл с постусловием (do…while)

Иногда возникает необходимость, чтобы тело цикла выполнилось хотя бы один раз, но условие не позволяет этому случится. Вот именно тут нам поможет цикл с постусловие do…while. Который реализован следующей конструкцией:

do оператор while (выражение);

Работает цикл следующим образом. В начале выполняется оператор, затем вычисляется значение выражения. Если оно истинно, оператор тела цикла выполняется еще раз.

Рассмотрим код на примере прошлой программы, изменив некоторые строки.

#include “stdafx.h”

#include <iostream>

using namespace std;

int main ()

{

int x, y, i, pen; //описаваем нужные переменные

x=0; //стартовое значение переменной

y=56; //определяем пенсионный возраст

{

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++
Динамические матрицы в C++
C++. Функции. Передача параметров. Оператор return
Работа с List Box в Visual C++
Visual C++. Использование MFC-приложений

Источник

Обновл. 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 в цикле, если на это нет веских причин.

Оценить статью:

Загрузка…

Источник