7.7 – Введение в циклы и инструкции while
А теперь начинается самое интересное – в следующем наборе уроков мы пройдемся по циклам. Циклы – это конструкции управления порядком выполнения программы, которые позволяют фрагменту кода многократно выполняться до тех пор, пока не будет выполнено какое-либо условие. Циклы добавляют в ваш набор инструментов программирования значительную гибкость, позволяя делать многие вещи, которые в противном случае были бы сложными.
Например, предположим, что вы хотите вывести все числа от 1 до 10. Без циклов вы можете попробовать что-то вроде этого:
#include int main()
Хотя это выполнимо, но всё усложняется, когда вы хотите напечатать больше чисел: что, если вы хотите напечатать все числа от 1 до 1000? А это совсем немного! Но такую программу возможно написать, потому что во время компиляции мы знаем, сколько чисел мы хотим напечатать.
Теперь давайте немного изменим требования. Что, если бы мы хотели попросить пользователя ввести число, а затем распечатать все числа от 1 до числа, введенного пользователем? Число, которое введет пользователь, неизвестно во время компиляции. Итак, как мы можем решить эту проблему?
Язык Си для начинающих / #5 — Циклы и операторы в них
Инструкции while
Инструкция while (также называемая циклом while ) является самым простым из трех типов циклов, предоставляемых C++, и имеет определение, очень похожее на определение оператора if :
while (условие) инструкция;
Инструкция while объявляется с помощью ключевого слова while . При выполнении инструкции while вычисляется условие. Если условие истинно, выполняется связанная инструкция.
Однако, в отличие от оператора if , после завершения выполнения инструкции управление возвращается в начало оператора while , и процесс повторяется. Это означает, что оператор while будет продолжать цикл до тех пор, пока условие будет истинным.
Давайте посмотрим на простой цикл while , который выводит все числа от 1 до 10:
#include int main() < int count< 1 >; while (count std::cout
Эта программа выводит:
1 2 3 4 5 6 7 8 9 10 done!
Хотя эта программа представляет собой немного больше кода, чем набор всех чисел от 1 до 10, подумайте, насколько легко было бы изменить эту программу для печати всех чисел от 1 до 1000: всё, что вам нужно сделать, это изменить count
Инструкции while , которые изначально вычисляются как ложные
Обратите внимание, что если условие изначально вычисляется как ложное, связанная инструкция не будет выполняться вообще. Рассмотрим следующую программу:
#include int main() < int count< 15 >; while (count std::cout
Бесконечные циклы
И наоборот, если условное выражение всегда истинно, цикл while будет выполняться вечно. Это называется бесконечным циклом. Вот пример бесконечного цикла:
#include int main() < int count< 1 >; while (count return 0; // эта строка никогда не будет выполнена >
Преднамеренные бесконечные циклы
Мы можем намеренно объявить бесконечный цикл следующим образом:
Циклы. Цикл while. Что это. Что делает. Пример. Синтаксис. Урок #14.
while (true) < // этот цикл будет выполняться вечно >
Единственный способ выйти из бесконечного цикла – использовать инструкцию return , инструкцию break , инструкцию exit , инструкцию goto , сгенерировать исключение, или пользователю убить программу.
Вот глупый пример, демонстрирующий это:
#include int main() < while (true) // бесконечный цикл < std::cout ; std::cin >> c; if (c == ‘n’) return 0; > return 0; >
Эта программа будет непрерывно повторяться до тех пор, пока пользователь не введет n в качестве входных данных, после чего оператор if вычислит значение true ,и связанный с ним return 0; вызовет выход из функции main() , завершив программу.
Такой цикл часто можно увидеть в приложениях веб-серверов, которые работают непрерывно и обслуживают веб-запросы.
Лучшая практика
Для преднамеренных бесконечных циклов используйте while (true) .
Переменные цикла
Часто нам нужно, чтобы цикл выполнялся определенное количество раз. Для этого обычно используется переменная цикла, часто называемая счетчиком. Переменная цикла – это целочисленное значение, которое используется для подсчета количества выполнений цикла. В приведенных выше примерах переменной цикла является переменная count .
Переменным цикла часто дают простые имена, такие как i , j или k . Однако если вы хотите знать, где в вашей программе используется переменная цикла, и вы используете функцию поиска по i , j или k , функция поиска вернет половину вашей программы! По этой причине некоторые разработчики предпочитают использовать такие имена переменных цикла, как iii , jjj или kkk . Поскольку эти имена более уникальны, это значительно упрощает поиск переменных цикла и помогает им выделяться как переменные цикла. Еще лучше – использовать «настоящие» имена переменных, такие как count , или имя, которое дает более подробную информацию о том, что вы подсчитываете (например, userCount ).
Переменные цикла должны быть со знаком
Переменные цикла почти всегда должны быть со знаком, поскольку целые числа без знака могут привести к неожиданным проблемам. Рассмотрим следующий код:
#include int main() < unsigned int count< 10 >; // счетчик от 10 до 0 while (count >= 0) < if (count == 0) < std::cout else < std::cout —count; > return 0; >
Взгляните на приведенный выше пример и посмотрите, сможете ли вы обнаружить ошибку. Она не очень очевидна.
Оказывается, эта программа представляет собой бесконечный цикл. Она начинается, как и предполагалось, с печати 10 9 8 7 6 5 4 3 2 1 blastoff! , но затем сходит с рельсов и начинает обратный отсчет с 4294967295 . Почему? Потому что условие цикла count >= 0 никогда не будет ложным! Когда count равен 0, условие 0 >= 0 истинно. Затем выполняется —count , и count переходит к 4294967295 (предполагается, что int занимает 32 бита).
И поскольку 4294967295 >= 0 истинно, программа продолжается. Поскольку count не имеет знака, он никогда не может быть отрицательным, а поскольку он никогда не может быть отрицательным, цикл не завершится.
Лучшая практика
Переменные цикла должны иметь тип ( signed ) int .
Выполнение чего-то при каждой N-ой итерации
Каждый раз, когда цикл выполняется, это называется итерацией.
Часто мы хотим делать что-то на каждой 2-й, 3-й или 4-й итерации, например, выводить символ новой строки. Это легко сделать с помощью оператора взятия остатка от деления для нашего счетчика:
#include // Перебираем все числа от 1 до 50 int main() < int count< 1 >; while (count std::cout // увеличиваем счетчик цикла ++count; > return 0; >
Эта программа дает следующий результат:
01 02 03 04 05 06 07 08 09 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
Вложенные циклы
Циклы также возможно вкладывать внутрь других циклов. В следующем примере внутренний и внешний циклы имеют свои собственные счетчики. Однако обратите внимание, что условное выражение внутреннего цикла также использует счетчик внешнего цикла!
#include // Цикл от 1 до 5 int main() < int outer< 1 >; while (outer ; while (inner // выводим символ новой строки в конце каждой строки std::cout return 0; >
Эта программа печатает:
1 1 2 1 2 3 1 2 3 4 1 2 3 4 5
Небольшой тест
Вопрос 1
Почему в приведенной выше программе переменная inner объявляется внутри блока while , а не сразу после объявления outer ?
Переменная inner объявляется внутри блока while , поэтому она создается (и повторно инициализируется значением 1) каждый раз при выполнении внешнего цикла. Если бы переменная inner была объявлена перед внешним циклом while , ее значение никогда не было бы сброшено до 1, или нам пришлось бы делать это с помощью оператора присваивания. Кроме того, поскольку переменная inner используется только внутри блока внешнего цикла while , имеет смысл объявить ее там. Помните, что мы объявляем переменные в минимально возможной области видимости!
Вопрос 2
Напишите программу, которая печатает буквы от a до z вместе с их кодами ASCII.
Чтобы напечатать символы как целые числа, вы должны использовать static_cast .
#include int main() < char myChar< ‘a’ >; while (myChar (myChar) return 0; >
Вопрос 3
Инвертируйте пример вложенных циклов, чтобы он напечатал следующее:
5 4 3 2 1 4 3 2 1 3 2 1 2 1 1
#include // Цикл от 5 до 1 int main() < int outer< 5 >; while (outer >= 1) < // цикл от inner до 1 int inner< outer >; while (inner >= 1) < std::cout // выводим символ новой строки в конце каждой строки std::cout return 0; >
Вопрос 4
Теперь напечатайте числа так:
1 2 1 3 2 1 4 3 2 1 5 4 3 2 1
Подсказка: сначала выясните, как печатать вот так:
X X X X 1 X X X 2 1 X X 3 2 1 X 4 3 2 1 5 4 3 2 1
#include int main() < // Есть 5 строк, мы можем выполнять цикл от 1 до 5 int outer< 1 >; while (outer ; while (inner >= 1) < // Первое число в любой строке совпадает с номером строки // Значит, число должно быть напечатано, только если оно // Строка напечатана, перейти к следующей строке std::cout return 0; >
Теги
Сохранить или поделиться
На сайте работает сервис комментирования DISQUS, который позволяет вам оставлять комментарии на множестве сайтов, имея лишь один аккаунт на Disqus.com.
В случае комментирования в качестве гостя (без регистрации на disqus.com) для публикации комментария требуется время на премодерацию.
Присоединяйтесь к нам во ВКонтакте!
- Антенны и распространение радиоволн
- Беспроводная связь
- Высокочастотная техника
- Волоконно-оптические линии связи (ВОЛС)
- Измерительная техника
- Исполнительные механизмы и драйверы
- САПР
- Спутниковая связь
- Схемотехника
- Телевидение
- Цифровая электроника
- Технологии и инструменты
- Электронные компоненты
- А что внутри?
- Прочее (радиоэлектроника)
- Алгоритмы и структуры данных
- Базы данных
- Веб-разработка
- Мультимедиа (разработка ПО)
- Нейронные сети
- Паттерны проектирования
- Связь
- Языки программирования
- Компьютерные сети
- Операционные системы
- Верстка
- Системы контроля версий
- История технологий
- Мультимедиа
- Новости телекома
- Нормативная документация
- Охрана труда
- Полезные программы
- Просто интересно
- Экономика телекоммуникаций и электронной промышленности
- Экономика и инвестиции
Мы в соцсетях
Источник: radioprog.ru
Цикл while в C++
Оператор цикла while или цикл while — цикл, повторяющий одно и то же действие, пока условие продолжения цикла while остаётся истинным.
// форма записи цикла while while (/*условие продолжения цикла while*/) < /*блок операторов*/; /*управление условием*/; >
Условие продолжения цикла должно быть истинно true , как только условие стало ложным, выполняется выход из цикла. Также как и в условных операторах выбора, фигурные скобочки могут опускаться в том случае, если тело цикла — это один оператор. Но как правило в цикле выполняется несколько операторов, так как кроме выполнения полезного действия необходимо делать условие цикла while ложным, иначе цикл будет бесконечным, а это, в свою очередь, приведет к зависанию программы.
Рассмотрим применение цикла while на примере движения автомобиля. На псевдокоде, то это будет так:
// Пока скорость движения автомобиля меньше 60 км/ч, продолжать наращивать скорость.
Истинным условием цикла, в данном случае, является скорость автомобиля меньше 60 км/ч, а ложным — скорость автомобиля больше или равно 60 км/ч. Повторение цикла будет продолжаться до тех пор пока скорость автомобиля не станет больше или равно 60 км/ч, после наступления этого момента условие цикла станет ложным, и программа выйдет из цикла. Рассмотрим фрагмент кода на C++ с циклом while решающим поставленную задачу.
int speed = 5; // начальная скорость автомобиля while ( speed < 60 ) // заголовок цикла while speed += 10; // тело цикла
// while.cpp: определяет точку входа для консольного приложения. #include «stdafx.h» #include using namespace std; int main(int argc, char* argv[]) < int speed = 5, count = 1; while ( speed < 60 ) < speed += 10; // приращение скорости cout system(«pause»); return 0; >
Итак, в строке 14 добавил переменную-счётчик, для подсчёта прохождений цикла.
Тело цикла увеличилось, поэтому пришлось поставить фигурные скобочки. Результат работы программы (см. Рисунок 1).
Рисунок 1 — Цикл while в C++
Как я и говорил, всего 6 повторений цикла и после выхода из цикла while переменная speed = 65 .
Для закрепления материала по циклу while разработаем всем известную игру «Отгадай число». На псевдокоде это будет так:
// Пока загаданное число не угадано, продолжать угадывать его
Загадывать число будет компьютер, а мы — отгадывать. Используя генератор случайных чисел, компьютер загадает число от 1 до 10, включительно, пока мы не отгадаем число выход из цикла не произойдет.
// ygadai.cpp: определяет точку входа для консольного приложения. #include «stdafx.h» #include #include using namespace std; int main(int argc, char* argv[]) < srand( time( 0 ) ); int unknown_number = 1 + rand() % 10; // загадываемое число int enter_number; // переменная для хранения введённого числа cout > enter_number; while ( enter_number != unknown_number ) < cout > enter_number; // продолжаем отгадывать > cout
Чтобы войти в цикл необходимо инициализировать переменную enter_number , тогда цикл while начнёт корректную проверку условия, вот для этого перед циклом while мы запрашиваем пользователя ввести число. После того как пользователь ввёл число, начинает работать цикл while , выйти из которого получится только в случае угадывания числа. результат работы программы (см. Рисунок 2).
Рисунок 1 — Цикл while в C++
Я отгадал число с третьей попытки, а Вы, с какой сможете??
Источник: cppstudio.com
While c что это за программа
Для выполнения некоторых действий множество раз в зависимости от определенного условия используются циклы. В языке C++ имеются следующие виды циклов:
Цикл while
Цикл while выполняет некоторый код, пока его условие истинно, то есть возвращает true. Он имеет следующее формальное определение:
while(условие) < // выполняемые действия >
После ключевого слова while в скобках идет условное выражение, которое возвращает true или false. Затем в фигурных скобках идет набор инструкций, которые составляют тело цикла. И пока условие возвращает true, будут выполняться инструкции в теле цикла.
Например, выведем квадраты чисел от 1 до 9:
#include int main() < int i = 1; while(i < 10) < std::cout 1 * 1 = 1 2 * 2 = 4 3 * 3 = 9 4 * 4 = 16 5 * 5 = 25 6 * 6 = 36 7 * 7 = 49 8 * 8 = 64 9 * 9 = 81
Каждый отдельный проход цикла называется итерацией. То есть в примере выше было 9 итераций.
Если цикл содержит одну инструкцию, то фигурные скобки можно опустить:
int i = 0; while(++i < 10) std::cout for (выражение_1; выражение_2; выражение_3) < // тело цикла >
выражение_1 выполняется один раз при начале выполнения цикла и представляет установку начальных условий, как правило, это инициализация счетчиков — специальных переменных, которые используются для контроля за циклом.
выражение_2 представляет условие, при соблюдении которого выполняется цикл. Как правило, в качестве условия используется операция сравнения, и если она возвращает ненулевое значение (то есть условие истинно), то выполняется тело цикла, а затем вычисляется выражение_3 .
выражение_3 задает изменение параметров цикла, нередко здесь происходит увеличение счетчиков цикла на единицу.
Например, перепишем программу по выводу квадратов чисел с помощью цикла for:
#include int main() < for(int i =1; i < 10; i++) < std::cout 1 * 1 = 1 2 * 2 = 4 3 * 3 = 9 4 * 4 = 16 5 * 5 = 25 6 * 6 = 36 7 * 7 = 49 8 * 8 = 64 9 * 9 = 81
Необязательно указывать все три выражения в определении цикла, мы можем одно или даже все из них опустить:
int i = 1; for(; i < 10;) < std::cout #include int main() < for (int i=1; i < 10; i++) < for(int j = 1; j < 10; j++) < std::cout std::cout return 0; >
Цикл do
В цикле do сначала выполняется код цикла, а потом происходит проверка условия в инструкции while. И пока это условие истинно, то есть не равно 0, то цикл повторяется. Формальное определение цикла:
do < инструкции >while(условие);
#include int main() < int i = 6; do < std::cout while(i>0); return 0; >
Здесь код цикла сработает 6 раз, пока i не станет равным нулю.
Но важно отметить, что цикл do гарантирует хотя бы однократное выполнение действий, даже если условие в инструкции while не будет истинно. То есть мы можем написать:
int i = -1; do < std::cout while(i>0); >
Хотя у нас переменная i меньше 0, цикл все равно один раз выполнится.
Операторы continue и break
Иногда возникает необходимость выйти из цикла до его завершения. В этом случае можно воспользоваться оператором break . Например:
#include int main() < int i = 1; for ( ; ; ) < std::cout continue производит переход к следующей итерации. Например, нам надо посчитать сумму только нечетных чисел из некоторого диапазона:
Источник: metanit.com
Оператор while (C)
Оператор while позволяет повторять выполнение оператора до тех пор, пока указанное выражение не станет ложным.
Синтаксис
оператор-итерации:
while (expression)statement
Выражение expression должно иметь арифметический тип или тип указателя. Выполнение происходит следующим образом:
- Вычисляется значение expression.
- Если expression изначально ложно, тело оператора while не выполняется ни одного раза и управление передается из оператора while следующему оператору в программе. Если expression имеет значение True (то есть не равно нулю), выполняется тело оператора и процесс повторяется с шага 1.
Выполнение оператора while прерывается, если в теле оператора выполняется оператор break , goto или return . Для прерывания итерации без выхода из цикла while используйте оператор continue . Оператор continue передает управление в следующую итерацию оператора while .
Ниже приводится пример оператора while .
while ( i >= 0 )
В этом примере производится копирование символов из string2 в string1 . Если значение i больше или равно 0, значение string2[i] присваивается элементу string1[i] и значение переменной i уменьшается на единицу. Когда значение переменной i становится равным 0 (или меньше 0), выполнение оператора while прекращается.
Источник: learn.microsoft.com