Тема: «Операторы цикла на С++»
План
Обстоятельства нередко вынуждают программу выполнять неоднократно
повторяющиеся задачи. Имеющийся в C++ цикл for
упрощает эту задачу.
Цикл for
предоставляет способ поэтапного выполнении
повторяющихся действий. Элементы цикла for позволяют выполнять такие этапы,
как:
Оператор цикла имеет вид:
for (инициализация; условие продолжения;
обновление счетчика)
тело цикла;
Конструкция цикла C++ позволяет располагать эти элементы таким образом,
чтобы их можно было сразу же обнаружить. Действия, связанные с инициализацией,
проверкой и обновлением переменной цикла, образуют область управления циклом,
состоящую из трех частей и заключенную в скобки. Каждая часть является выражением,
причем точки с запятой отделяют одно выражение от другого. Оператор, который
следует после области управления циклом, образует тело цикла и выполняется до тех пор, пока не становится ложным
условие продолжения цикла.
Инициализация цикла выполняется только один раз. Как правило,
это выражение применяется для задания начального значения переменной цикла,
после чего данная переменная может использоваться для подсчета количества
итераций цикла (в этом случае ее называют счетчиком
цикла).
Условие продолжения цикла определяет, следует ли завершить выполнение
цикла. Как правило, это выражение является выражением сравнения. Если
результат сравнения оказывается истинным, тогда программа выполняет тело цикла.
Цикл for
является циклом с входным условием (или с предусловием). Это означает, что
условие продолжения цикла проверяется перед выполнением каждой итерации цикла.
При этом тело цикла вообще не выполняется, если не выполняется условие его
продолжения.
Обновление переменной цикла происходит в конце цикла после выполнения его
тела. Обычно это приводит к увеличению или уменьшению значения переменной цикла
на величину, которая называется шагом
цикла.
Пример. Составить программу, которая выводит на экран
числа от 0 до 9.
#include <iostream.h>
int main()
{
system("chcp 1251>nul");
//описываем
переменную-счетчик цикла
int i;
//запускаем цикл от 0
до 9 с шагом 1
for (i=0; i<=9; i=i+1)
//в цикле выдаем значение
переменной-счетчика цикла
cout<<i<<"\n";
//делаем паузу для
просмотра
system("pause");
return 0;
}
Описание переменных внутри цикла
Язык С++ допускает описывать переменную-счетчик
цикла сразу в разделе инициализации. Это позволяет сократить текст программы. Тогда наш пример будет иметь вид:
#include <iostream.h>
int main()
{
system("chcp 1251>nul");
//запускаем цикл от 0
до 9 с шагом 1
//при этом переменная
i описывается в разделе инициализации
for (int i=0; i<=9; i=i+1)
cout<<i<<"\n";
system("pause");
return 0;
}
Существует один практический аспект объявления переменной и области
инициализации цикла, о котором следует знать. Такая переменная существует
только внутри оператора for. Это означает, что, после
того как программа покинет данный цикл, указанная переменная прекращает свое
существование.
Операторы инкремента (++) и декремента (--)
Для C++ характерно наличие нескольких операторов, которые часто используются
в циклах. С двумя из них мы уже познакомились. Это оператор инкремента (++), а также оператор декремента (—). Эти операторы
выполняют две чрезвычайно распространенные в цикле операции: увеличение и
уменьшение счетчика цикла на 1. Использование этих операторов позволяет короче
записывать оператор цикла. Например, рассмотренный выше пример можно записать
так:
#include <iostream.h>
int main()
{
system("chcp 1251>nul");
//запускаем цикл от 0
до 9 с шагом 1
for (int i=0; i<=9; i++)
cout<<i<<"\n";
system("pause");
return 0;
}
С помощью оператора for можно создавать циклы с отрицательным шагом. Выведем на экран цифры в
обратном порядке: от 9 до 0.
#include <iostream.h>
int main()
{
system("chcp 1251>nul");
//запускаем цикл от 9
до 0 с шагом -1
for (int i=9; i>=0; i--)
cout<<i<<"\n";
system("pause");
return 0;
}
Изменение шага цикла
В приведенных ранее примерах переменная цикла увеличивалась или уменьшалась
на 1 на каждой итерации цикла. Это приращение переменной цикла (или шаг цикла)
можно изменить в выражении обновления переменной цикла. Такая возможность
делает цикл for намного функциональнее.
Например. Пусть имеется функция вида: y=2sinx. Необходимо вывести
таблицу значений аргумента и функции. При этом аргумент изменяется на отрезке
от 5 до 19 с шагом 3,5.
#include <iostream.h>
#include <math.h>
int main()
{
system("chcp 1251>nul");
float x;
//выводим
шапку таблицы
cout<<"x\ty\n";
//задаем точность
вывода чисел
cout.precision(3);
//организуем
изменение аргумента х на
отрезке
//от
5 до 16 с шагом 3.5
for (x=5;x<=19;x=x+3.5)
//выдаем очередные
значения аргумента и функции
cout<<x<<"\t"<<2*sin(x)<<"\n";
system("pause");
return 0;
}
Использование комбинированных
операторов
Нередко в программах с циклами необходимо подсчитывать сумму или
произведение с нарастанием результата. Например, необходимо посчитать факториал
числа n (n!).
#include <iostream.h>
int main()
{
system("chcp 1251>nul");
int f,n,i;
//вводим число для
расчета
cout<<"Введите нужное
целое число: ";
cin>>n;
//вначале факториал
равен 1
f=1;
//в цикле считаем n!
//как произведение i*(i-1)*(i-2)*...*3*2*1
for (i=1; i<=n; i++)
f=f*i;
//выводим результат
cout<<"Факториал числа="<<f<<endl;
system("pause");
return 0;
}
В этой программе имеется оператор, подсчитывающий произведение с
нарастанием результата:
f=f*i;
В C++ имеется комбинированный оператор умножения и присваивания, который
даст тот же результат и является более компактным. Оператор имеет вид:
f*=i;
Оператор *= выполняет умножение левого и правого операндов и присваивает полученный результат левому операнду.
В таблице приведены все виды комбинированных операторов.
|
Операция |
Действие
L - левый операнд, R - правый операнд) |
|
L+=R |
L + R присваивается L |
|
L-=R |
L - R присваивается L |
|
L*=R |
L * R присваивается L |
|
L/=R |
L / R присваивается L |
|
L%=R |
L % R присваивается L |
Кроме этого, в программах с подсчетом нарастающих сумм или произведений
приходится использовать оператор, задающий начальное значение результату.
Например, в нашем примере имеется оператор:
f=1;
Для сокращения программы на этот оператор можно использовать два способа:
int f=1,n,i;
#include <iostream.h>
int main()
{
system("chcp 1251>nul");
int f,n,i;
cout<<"Введите нужное целое число: ";
cin>>n;
//инициализация
переменной f
for (f=1, i=1; i<=n; i++)
f=f*i;
cout<<"Факториал числа="<<f<<endl;
system("pause");
return 0;
}
Составные операторы или блоки
Все рассмотренные ранее примеры содержали внутри тела цикла один оператор.
Реальные задачи могут требовать повторения целого набора операторов. В этом
случае та группа операторов, которые входят в тело цикла, должна быть заключена
в фигурные скобки.
Например, посчитать сумму и произведение всех чисел на
отрезке от a до b.
#include <iostream.h>
int main()
{
system("chcp 1251>nul");
int s,p,a,b,i;
//вводим концы
отрезка
cout<<"Введите начало и конец отрезка: ";
cin>>a>>b;
//организуем цикл и
//инициализируем
значения суммы и произведения
for (s=0, p=1, i=a; i<=b; i++)
{
//считаем сумму с
нарастанием
s+=i;
//считаем
произведение с нарастанием
p*=i;
}
//выдаем ответ
cout<<"Сумма =
"<<s<<",
произведение = "<<p<<endl;
system("pause");
return 0;
}
Составные операторы обладают одним интересным свойством. Если внутри блока
определить новую переменную, то эта переменная будет продолжать существовать
до тех пор, пока программа выполняет операторы внутри блока. А по завершении
выполнения блока данная переменная становится недействительной. (начало)
Цикл while представляет собой цикл for без частей
инициализации и обновления счетчика цикла, при этом у него имеется только
условие продолжения цикла и тело. Цикл имеет вид:
while (условие продолжения цикла)
тело цикла;
Прежде всего, программа проверяет условие продолжения цикла. Если условие
выполняется (равно true), тогда программа выполняет
операторы в теле цикла. Подобно циклу for тело
данного цикла состоит из одного оператора или блока, определяемого парой
фигурных скобок. После завершения выполнения тела цикла программа возвращается
к условию продолжения цикла и проверяет его еще раз. Подобный цикл проверки и выполнения
продолжается до тех пор, пока в результате проверки условия не получится логическое
значение false. Чтобы цикл в конечном итоге был
завершен, в теле цикла должно быть выполнено некоторое действие, которое могло
бы оказать влияние на значение условия продолжения цикле. Например, в цикле
может быть выполнено приращение переменной-счетчика, используемой в условии
продолжения цикла. Подобно циклу for, while является циклом с входным условием
продолжения цикла. Таким образом, если в результате вычисления условие
продолжения цикла оказывается ложным с самого начала, программа вообще не
выполняет тело цикла.
Сравнение циклов for и while
В C++ циклы for и while, по существу, равнозначны. Благодаря тому, что
циклы for и while практически равнозначны, их применение является делом стиля.
С помощью цикла while можно переписать любую
программу, в которой использовался цикл for.
Например, найдем факториал числа n (n!).
#include <iostream.h>
int main()
{
system("chcp 1251>nul");
int f,n,i;
//вводим значение
числа
cout<<"Введите нужное
число: ";
cin>>n;
//инициализируем
начальное значение факториала
f=1;
//инициализируем
начальное значение счетчика цикла
i=1;
//проверяем, не
превысил ли счетчик значения числа
while (i<=n)
{
//считаем факториал
f*=i;
//увеличиваем счетчик
цикла на 1
i+=1;
}
//выводим результат
cout<<"Факториал числа =
"<<f<<endl;
system("pause");
return 0;
}
Как правило, программисты применяют цикл for в качестве цикла со
счетчиком, поскольку формат цикла for позволяет размешать в одном месте все
необходимые вещи: начальное значение, конечное значение и способ обновления
переменной цикла (счетчика цикла). А цикл while чаще всего применяется в том
случае, когда заранее точно неизвестно, сколько раз должен быть выполнен цикл.
Цикл while удобно использовать для «зацикливания»
выдачи меню программы. В этом случае программа повторяет свою работу до тех
пор, пока не будет выбран некоторый пункт меню, соответствующий выходу из
программы.
Пример. Пусть дано два числа. Необходимо выдать меню вида:
1 – сумма
2 – разность
3 – произведение
4 – частное
5 – выход
Создать программу для обработки выбора из меню.
#include <iostream.h>
int main()
{
system("chcp 1251>nul");
//описываем и инициализируем исходные данные
float a=10, b=5;
//к - для выбора из меню, р - признак выхода из программы
int k, p=0;
//пока р=0 цикл повторяется
while (p==0)
{
//очищаем
экран
system("cls");;
//выдаем меню
пользователя
cout<<"1 - сумма\n";
cout<<"2 - разность\n";
cout<<"3 - произведение\n";
cout<<"4 - частное\n";
cout<<"5 - выход\n";
//запрашиваем выбор
режима и записываем в k
cout<<"Сделайте выбор: ";
cin>>k;
//обрабатываем выбор
из меню
switch (k)
{
//если выбран первый
пункт меню
case 1:
{
cout<<"Сумма = "<<a+b<<endl;
system("pause");
break;
}
//если выбран второй
пункт меню
case 2:
{
cout<<"Разность = "<<a-b<<endl;
system("pause");
break;
}
//если
выбран третий пункт меню
case 3:
{
cout<<"Произведение =
"<<a*b<<endl;
system("pause");
break;
}
//если выбран
четвертый пункт меню
case 4:
{
cout<<"Частное = "<<a/b<<endl;
system("pause");
break;
}
//если
выбран пятый пункт меню
case 5:
{
//р
не равно 1, значит цикл завершается
p=1;
break;
}
} //конец switch
} //конец while
return 0;
} (начало)
3.
Структура цикла DO WHILE
Третьим типом цикла в C++ является цикл do while. От двух предыдущих циклов он отличается тем, что это
цикл с постусловием. Это означает, что сначала выполняется тело цикла и только
после этого оценивается условие продолжения цикла. Если в результате оценки
условия получается логическое значение false, тогда данный цикл завершается. В
противном случае начинается новый этап выполнения и проверки цикла. Подобный
цикл всегда выполняется, по крайней мере, один раз, поскольку процесс
выполнения программы должен пройти тело цикла, прежде чем будет осуществлена
проверка условия продолжения. Ниже приведен синтаксис рассматриваемого цикла:
do
тело цикла
while (условие продолжения цикла);
Тело рассматриваемого цикла может состоять из одного оператора или
ограниченного фигурными скобками блока операторов. Как правило, лучше выбирать
цикл с предусловием, чем с постусловием, поскольку в
первом случае проверка осуществляется до выполнения цикла.
Перепишем предыдущий пример с меню, используя цикл do
while.
#include <iostream.h>
int main()
{
system("chcp 1251>nul");
//описываем и инициализируем исходные данные
float a=10,b=5;
//к - для выбора из меню, р - признак выхода из программы
int k,p=0;
//начинаем выполнять цикл с постусловием
do
{
//очищаем экран
system("cls");
//выдаем меню пользователя
cout<<"1 - сумма\n";
cout<<"2 - разность\n";
cout<<"3 - произведение\n";
cout<<"4 - частное\n";
cout<<"5 - выход\n";
//запрашиваем выбор режима и записываем в к
cout<<"Сделайте
выбор: ";
cin>>k;
//обрабатываем выбор из меню
switch (k)
{
//если выбран первый
пункт меню
case 1:
{
cout<<"Сумма =
"<<a+b;
system("pause");
break;
}
//если выбран второй
пункт меню
case 2:
{
cout<<"Разность =
"<<a-b;
system("pause");
break;
}
//если выбран третий
пункт меню
case 3:
{
cout<<"Произведение
= "<<a*b;
system("pause");
break;
}
//если выбран
четвертый пункт меню
case 4:
{
cout<<"Частное =
"<<a/b;
system("pause");
break;
}
//если выбран пятый
пункт меню
case 5:
{
//р не равно 1, значит цикл завершается
p=1;
break;
}
} //конец switch
}
//пока р=0 цикл
повторяется
while (p==0);
return 0;
} (начало)