Меню сайта

Урок 8. Повторение одного или нескольких операторов (for, while, do-while) в C++


ПОВТОРЕНИЕ ОПЕРАТОРОВ УКАЗАННОЕ ЧИСЛО РАЗ

Одной из наиболее широко используемых операций в ваших программах является повторение одного или нескольких операторов определенное число раз. Например, одна программа могла бы повторять один и тот же оператор, чтобы напечатать пять копий файла, а другая могла бы повторять некоторый Набор операторов 30 раз, чтобы определить, поднялась или упала цена ваших 30 акций. Оператор C++ —for —предоставляет чрезвычайно простую возможность вашим программам повторять один или несколько операторов указанное число раз.

Если ваша программа использует оператор —for —(часто называемый циклом —for), —она должна указать переменную, которая называется —управляющей переменной, —хранящей количество выполнений цикла. Например, следующий —цикл —for —использует переменную —count дляхранения количества выполнений цикла. В данном случае цикл будет выполнен десять раз.

for (count = 1- count &lt-= 10- count++) —
— — — оператор-

Цикл —for —состоит из четырех частей. Первые три части управляют количеством выполнений цикла. Сначала оператор —count = 1, —присваивает переменной управления начальное значение. Цикл —for —выполняет эту инициализацию один раз при запуске цикла. Далее цикл проверяет условие —count &lt-= 10. —Если условие истинно, цикл —for —выполняет следующий оператор. Если условие ложно, цикл завершается и программа продолжает свое выполнение с первого оператора, следующего за циклом. Если условие истинно и —цикл for —выполняет свой оператор, то после этого цикл увеличивает переменную —count, —используя операторcount++. —Далее программа проверяет условие —count &lt-= 10. —Если это условие все еще истинно, то опять повторяется выполнение оператора внутри цикла, увеличение и проверка переменной —count

for — — — — — — — — —(count = 1- — — — — — — — — — — — — — — — — — — —count &lt-= 10- — — — — — — — — — — — — — — — — —count++)

— — — — — — — — — — -Инициализация — — — — — — — — — — — — -Проверка — — — — — — — — — — — — — Увеличение

Следующая программа FIRSTFOR.CPP использует цикл —for —для вывода на экран дисплея значений от 1 до 100:

#include &lt-iostream.h&gt-

void main(void)

{ —
— — -int count- —
— — -for (count = 1- count &lt-=100- count++) cout &lt-&lt- count &lt-&lt-» «- —
}

Как видите, оператор —for —инициализирует переменную —count —значением 1. Затем цикл проверяет, меньше ли значение переменной —count или —равно 100. Если это так, цикл —forвыполняет соответствующий оператор и затем увеличивает —count, —повторяя проверку. Экспериментируйте с этой программой, изменяя значение 100 на 10, 20 и даже 5000.

Следующая программа ASKCOUNT.CPP выводит сообщение, запрашивающее пользователя ввести число, при котором цикл должен завершиться. Затем программа вы
водит числа от одного до указанного значения:

#include &lt-iostream.h&gt-

void main(void)

{ —
— — -int count- —
— — -int ending_value- —
— — -cout &lt-&lt- «Введите конечное значение и нажмите Enter: «- —
— — -cin &gt-&gt- ending_value- —
— — -for (count = 0- count &lt-= ending_value- count++) —
— — — — cout &lt-&lt- count &lt-&lt- » «- —
}

Экспериментируйте с этой программой, вводя разные числа, например 10, 1 и даже 0. Если вы вводите значение 0 или 1, цикл —for —никогда не выполняется, потому что условие —count &lt-= ending_value —сразу же ложно. Помните, если вы введете значение вне диапазона значений, которые может хранить переменная типа —int, —возникнет ошибка переполнения. Например, запустите программу и введите значение 50000. Поскольку это значение превышает наибольшее возможное для переменной типа —int, —то переполнение приводит к отрицательному значению, которое предотвращает выполнение цикла.

Циклы —for C++ —поддерживают составные операторы

Из урока 7 вы узнали, что если программы выполняют несколько операторов внутри —if или else, —то такие операторы следует сгруппировать внутри левой и правой фигурных скобок. Это же относится и к нескольким операторам в цикле —for. —Следующая программа ADD1_100.CPP зацикливает числа от 1 до 100, выводя и добавляя каждое число в общий итог:

#include &lt-iostream.h&gt-

void main(void)

{ —
— — -int count- —
— — -int total = 0- —
— — -for (count = 1- count &lt-= 100- count++) —
— — — — — -{ —
— — — — — — — — -cout &lt-&lt- «Прибавляю » &lt-&lt- count &lt-&lt- » к » &lt-&lt- total- —
— — — — — — — — -total = total + count- —
— — — — — — — — -cout &lt-&lt- » получаю » &lt-&lt- total &lt-&lt- endl- —
— — — — — — -} —
}

Группируя операторы внутри фигурных скобок, цикл —for —тем самым может выполнить несколько операторов за один проход (называемый —umepa-цией —цикла).

Изменение и увеличение цикла —for

Все представленные до настоящего момента циклы —for —увеличивали управляющую переменную цикла на 1 на каждой итерации цикла. Однако цикл —for —не обязывает ваши программы увеличивать эту переменную на единицу. Следующая программа BY_FIVES.CPP выводит каждое пятое число в диапазоне от 0 до 100:

#include &lt-iostream.h&gt-

void main(void)

{ —
— — -int count- —
— — -for (count = 0- count &lt-= 100- count += 5) —
— — — — — — —
cout &lt-&lt- count &lt-&lt- —» «»- —
}

Если вы откомпилируете эту программу, на вашем экране будут отображаться числа 0, 5,10 и т. д. до 100. Обратите внимание, что оператор цикла for —использует для увеличения переменную —count.

count += 5-

Если вы хотите добавить некоторое значение к текущему значению переменной, а затем присвоить результат той же переменной, C++ позволяет вам сделать это двумя способами. Первый: предположим, вашей программе необходимо добавить значение 5 к переменнойcount, —это можно сделать, как показано ниже:

count = count + 5-

Второй: C++ позволяет вам использовать краткую запись, представленную ниже, для добавления значения 5 к переменной —count.

count += 5-

Поскольку это легче записать, то данная краткая форма является общепринятой внутри циклов.

При использовании цикла —for —вы не обязаны продвигать счетчик в сторону увеличения. Следующая программа CNT_DOWN.CPP использует цикл —for —для вывода чисел в порядке уменьшения от 100 до 1:

#include &lt-iostream.h&gt-

void main(void)

{ —
— — -int count — —
— — -for (count = 100- count &gt-= 1- count—) —
— — — — — — cout &lt-&lt- count &lt-&lt- » «- —
}

Как —видите, цикл —for —инициализирует переменную —count —значением 100. —На —каждой итерации цикл уменьшает значение этой переменной на 1. Цикл завершается, когда переменная —count —содержит значение 0.

Остерегайтесь бесконечных циклов

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

К сожалению, из-за ошибок в программах в некоторых случаях цикл никогда не достигает своего завершающего условия и, таким образом, зацикливается навсегда (или до тех пор, пока вы не прервете программу). Такие не завершающиеся циклы называются бесконечными циклами. Другими словами, это циклы, не имеющие способа для завершения. Например, следующий оператор for создает бесконечный цикл:

for (count = 0- count &lt- 100- wrong_variable++) —
— — -// операторы

Как видите, цикл for использует переменную count в качестве своей управляющей переменной. Однако в секции цикла увеличения программа увеличивает не ту переменную. В результате цикл никогда не увеличивает переменную count, и она никогда не будет иметь значение больше или равно 100. Таким образом, этот цикл превращается в никогда не завершающийся бесконечный цикл.

Важно обратить внимание, что циклы —for —не ограничиваются использованием переменных типа —int —в качестве их управляющих переменных. Например, следующая программа LOOPVAR.CPP использует переменную типа —char —для вывода букв алфавита внутри одного цикла и переменную типа —float —для вывода чисел с плавающей точкой внутри другого цикла:

#include &lt-iostream.h&gt-

void main(void)

{ —
— — -char letter- —
— — -float value- —
— — -for (letter = «A»- letter &lt-= «Я»- letter++) —
— — — — — — cout &lt-&lt- letter- —
— — -cout &lt-&lt- endl- —
— — -for (value = 0.0- value &lt-= 1.0- value += 0.1) —
— — — — — — cout &lt-&lt- value &lt-&lt- » «- —
— — -cout &lt-&lt- endl- —
}

Если вы откомпилируете и запустите эту программу, на экране появится следующий вывод:

АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ

0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9

Повторение цикла определенное число раз

Одна из наиболее общих операций, которую будут выполнять ваши программы, состоит в повторении одного или нескольких операторов определенное количество раз. Оператор C++ for позволяет вашим программам сделать именно это. Такой оператор for использует управляющую переменную, хранящую количество выполнений цикла. Общий формат оператора for выглядит так:

for (инициализация- проверка- увеличение) —
— — — оператор-

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

ВЗГЛЯД НА ЦИКЛ —while

Как вы только что узнали, цикл —C++ for —позволяет вашим программам повторять один или несколько операторов определенное количество раз. Однако в некоторых случаях программе необходимо повторять операторы, пока удовлетворяется (истинно) некоторое условие. Например, в следующих уроках вы узнаете, как читать содержимое файла. Такие программы могли бы повторять цикл, пока не встретится конец файла. В ситуациях, когда программам необходимо выполнять цикл, пока удовлетворяется некоторое условие (но не обязательно определенное количество раз), ваши программы могут использовать оператор C++ —while.Общий формат оператора —whil
e —
выглядит так:

while (условие_верно) —
— — — оператор-

Если ваша программа встречает оператор —while, —она проверяет заданное условие. Если условие истинно, программа выполняет операторы цикла —while. —После выполнения последнего оператора в цикле, цикл —while —опять проверяет условие. Если условие все еще истинно, повторяются операторы —цикла и повторяется данный процесс. Когда условие, наконец, становится ложным, цикл завершается и программа продолжает свое выполнение с первого оператора, следующего за циклом. Следующая программа GET_YN.CPP просит вас ввести Д для —да —или —Н —для —нет. —Затем программа использует цикл while для чтения символов с клавиатуры, пока пользователь не введет —Д —или —Н. —Если пользователь вводит значение, отличное от —Д —или —Н, —программа сигналит встроенным динамиком, записывая символ сигнала «а» в выходной поток —cout —:

#include &lt-iostream.h&gt-

void main(void)

{ —
— — -int done = 0- // Устанавливается в состояние „истина», —если введены Д или Н char letter- —
— — -while (! done)

— — -{ —
— — — — — -cout &lt-&lt- » Введите Д или Н» —&lt-&lt- » и нажмите Enter для продолжения: «- —
— — — — — -cin &gt-&gt- letter- —
— — — — — -if ((letter == «Д») II (letter == «д»)) —
— — — — — — — — -done = 1- —
— — — — — — — — -else if ((letter == «Н» —) —II (letter == «н»)) —
— — — — — — — — — — — -done = 1- —
— — — — — — — — — — — -else cout &lt-&lt- «а»- // Играть сигнал динамика для неверного символа —
— — — — — -} —
— — -cout &lt-&lt- «Вы ввели букву » &lt-&lt- letter &lt-&lt- endl- —
}

Как видите, цикл —while —тоже поддерживает несколько операторов, сгруппированных внутри левой и правой фигурных скобок. В данном случае программа использует переменную —doneдля управления циклом. Пока программа не завершится (т. е. пока пользователь не введет —Дили —Н), —цикл продолжает выполняться. Когда пользователь вводит —Д —или Я, программа устанавливает переменную —done —в значение истина и цикл завершается. Как только ваши программы начнут работать с файлами, вы регулярно будете использовать цикл —while.

Повторение цикла до выполнения заданного условия

По мере усложнения ваших программ им, возможно, понадобится выполнять группы связанных операторов, пока не реализуется заданное условие. Например, программа может вычислять суммы платежей для служащих компании. В этом случае цикл будет выполняться до тех пор, пока не обработаны данные для последнего служащего. Для повторения операторов до выполнения заданного условия программы как правило, будут использовать оператор while:

while (условие) —
— — -оператор-

Сталкиваясь с оператором while, программа будет оценивать условие цикла. Если условие истинно, ваша программа выполняет операторы цикла while. После выполнения последнего оператора цикла программа снова проводит проверку условия. Если условие истинно, программа повторит этот процесс, выполнит операторы, а затем повторит проверку условия. Если условие оценивается как ложь, программа продолжит свое выполнение с первого оператора, который следует за оператором while.

ВЫПОЛНЕНИЕ ОПЕРАТОРОВ ПО КРАЙНЕЙ МЕРЕ ОДИН РАЗ

Как вы уже знаете, цикл C++ —while —позволяет вашим программам повторять набор операторов, пока данное условие удовлетворяется. Когда программа встречает операторwhile, —она сначала оценивает заданное условие. Если условие истинно, программа входит в цикл. Если условие ложно, операторы цикла —while —никогда не выполняются. В зависимости от назначения ваших программ, возможны ситуации, когда некоторый набор операторов должен выполняться по крайней мере один раз, а затем выполнение, основываясь на некотором условии, может повторяться. В подобном случае ваши программы могут использовать цикл —do while:

do

{ —
— — -операторы- —
}

while (условие_истинно)-

Если программа встречает цикл —do while, —она входит в цикл и запускает выполнение операторов, содержащихся в цикле. Затем программа оценивает заданное условие. Если условие истинно, программа возвращается к началу цикла:

do —&lt——————————————

{ — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — -| —
— — -операторы- — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — | —
} — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — — -|

while (условие_истинно)- ————-

Если условие ложно, программа не повторяет инструкции цикла, продолжая вместо этого выполнение с первого оператора, следующего за циклом. Обычно цикл —do while —используется для отображения пунктов меню и затем обработки выбора пользователя. Вам требуется, чтобы программа отобразила меню по крайней мере один раз. Если пользователь выбирает какой-либо —пункт меню, кроме Quit, программа выполнит пункт, а затем отобразит меню снова (повторяя оператор цикла). Если пользователь выбирает Quit, цикл завершится и программа продолжит свое выполнение с первого оператора после цикла.

Повторение операторов, если условие истинно

В зависимости от назначения программы, возможно, потребуется выполнить набор операторов, по крайней мере, один раз, и повторить операторы, если заданное условие истинно. В таких случаях ваши программы используют оператор C++ do while:

do { —
— — -оператор- —
} while (условие)-

Когда программа встречает оператор do while, она сразу же выполняет операторы, содержащиеся в цикле. Затем программа исследует условие цикла. Если условие истинно, программа повторяет операторы цикла и процесс продолжается. Если условие цикла становится ложным, программа продолжает свое выполнение с первого оператора, следующего за оператором do while.

ЧТО ВАМ НЕОБХОДИМО ЗНАТЬ

Итеративная обработка —представляет собой способность программы повторять один или несколько операторов. В этом уроке были описаны итеративные (или циклические) операторы C++. Как вы уже знаете, оператор —for —позволяет вашим программам повторять один или несколько операторов заданное число раз. Используя оператор —while, —программы повторяют операторы до тех пор, пока указанное условие истинно. Наконец, с помощью оператора —do while —программы выполняют операторы, по крайней мере один раз, повторяя их, если заданное условие истинно. Из урока 9 вы узнаете, как разделить программы на небольшие легко управляемые части, называемые —функциями. —Однако до изучения урока 9 убедитесь, что освоили следующее:

    1. Оператор —C++ for —позволяет вашим программам повторять один или более операторов заданное число раз.
    2. Оператор —for —состоит из четырех частей: инициализации, проверяемого условия, операторов, которые повторяются, и приращения.
    3. Оператор —for —не обязывает вас увеличивать управляющую переменную цикла именно на 1 или использовать именно приращение.
    4. Цикл C++ —while —позволяет вашим программам повторять операторы, пока указанное условие истинно.
    5. Программы часто используют цикл —while —для чтения содержимого файла, пока не встретится конец файла.
    6. Оператор C++ —do while —позволяет вашим программам выполнять один или несколько операторов, по крайней мере один раз, и воз можно, повторять их на основании заданного условия.
    7. Программы часто используют операторы —do while —для работы с меню
    8. Если проверяемые условия в циклах, —while —или —do while —становятся ложью, программа продолжает свое выполнение с первого оператора, следующего за циклом.

Категория: Обучение C++ | Дата: 25.03.13

Меню раздела
Блок