Цикл do while выведет 10

#Руководства

8 июн 2020
14

Разбираемся, как сократить повторяющийся код в C++ и сэкономить время.

nbsp;4.0 Transitional//EN” “https://www.w3.org/TR/REC-html40/loose.dtd”>

Это шестая часть из серии статей «Глубокое погружение в C++». В прошлый раз мы узнали, как использовать функции и процедуры. Сейчас поговорим о циклах while, do-while и for.

Циклы – это разновидность условных конструкций. Они позволяют выполнять команды несколько раз, если определённое утверждение верно. Например, с помощью циклов можно пять раз вывести на экран какую-нибудь надпись или посчитать сумму всех чисел.

Евгений Кучерявый

Пишет о программировании, в свободное время создает игры. Мечтает открыть свою студию и выпускать ламповые RPG.

Запись цикла while выглядит так:

Этот код выполняется следующим образом:

Программа проверяет, верно ли утверждение.
Выполняются инструкции в теле цикла.
Программа возвращается к пункту 1.

То есть пока утверждение верно (i < 100), цикл будет повторять одни и те же действия. Цикл, который пять раз выводит сообщение «Hello, World!»:

int i = 0; while(i < 5) { std::cout << “Hello, World! n”; i++; }

Посмотрим на вывод:

Обратите внимание на переменную i – она играет роль счётчика, к которому в каждом шаге цикла прибавляется единица. Это нужно, чтобы инструкции выполнялись только определённое количество раз.

Один шаг цикла называется итерацией, а счётчик – итератором. Поэтому чаще всего для счётчика создаётся переменная i.

Важно! Следите за тем, чтобы выход из цикла был возможен, иначе он будет выполняться бесконечно.

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

Когда нам нужно вмешаться в работу цикла, мы используем операторы break и continue.

Оператор break прерывает выполнение цикла:

int sum = 0; int maxSum = 50; int i = 0; while(i < 100) { sum += i; i++; if(sum >= maxSum) { break; } } std::cout << “i = ” << i << “nsum = ” << sum << “n”;

Этот цикл должен посчитать сумму всех чисел от одного до ста. Но мы указали максимальное значение для переменной sum, поэтому цикл прервётся, как только sum станет больше maxSum.

Компилятор умеет отличать оператор break в конструкции switch от оператора break, который прерывает циклы. Поэтому можно спокойно писать вот такой код:

int action = 0; bool end = false; while(true) { std::cout << “Exit? n1 – Yesn0 – NonAction: “; std::cin >> action; switch(action) { case 1: std::cout << “Good bye!n”; end = true; break; case 0: std::cout << “Try again!n”; } if(end) { break; } }

Вот как это будет работать:

Важно! Оператор break внутри конструкции switch не может прервать цикл.

Иногда нам нужно пропустить одну итерацию и перейти к следующей. Для этого используем оператор continue.

int i = 0; while(i < 100) { i++; if(i % 3 == 0) { continue; } std::cout << ” ” << i; } std::cout << “n”;

Этот цикл выведет все числа от одного до ста, кроме тех, которые делятся на три без остатка.

Цикл do-while похож на while, но он сначала выполняет одну итерацию и только потом проверяет верность утверждения:

while(false) { std::cout << “Hello! n”; } do { std::cout << “Bye! n”; } while(false);

Вот результат:

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

Вот пример такого цикла:

int sum = 0; for(int i = 0; i < 200; i++) { sum += i; } std::cout << “sum = ” << sum << “n”;

В результате мы получим сумму всех чисел от 1 до 200:

Циклы, как и другие конструкции, можно размещать внутри других циклов. Вот, например, как вывести сетку с помощью for:

for(int i = 0; i < 10; i++) { for(int j = 0; j < 10; j++) { std::cout << ” + “; } std::cout << “n”; }

Получаем результат:

Важно! Операторы break и continue влияют на тот цикл, в котором они находятся, а не на родительский.

Циклы – одни из самых часто используемых конструкций в программировании. Они нужны при чтении данных из файлов, сортировке, отрисовке графики и так далее. Одно из самых полезных применений циклов связано с массивами, о работе с которыми будет отдельная статья.

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

Вы пройдёте полный курс по С++ и прикладной курс по Unreal Engine 4. Вы научитесь работать с многопоточностью, использовать инструменты и средства разработки: Git, GCC, GDB. Вам будет проще найти работу программиста в геймдеве.

1409

Источник

Цикл – это некий набор инструкций. Он выполняется до тех пор, пока его условие истинно. Давайте разберемся, как работает цикл while в Python.

Что такое цикл?

Циклы – фундаментальное понятие в программировании. Если вы новичок, то обязаны в них разобраться. Циклы могут помочь выполнять набор инструкций до тех пор, пока заданное условие истинно.

В Python есть два основных вида циклов:

Цикл for.
Цикл while.

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

Цикл while

Суть работы цикла while очень проста. Работает он так: ваши инструкции выполняются, пока условие истинно.

Цикл while проверяет условие перед каждой итерацией цикла. Если возвращается True, то выполняется блок кода внутри цикла.

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

А теперь напишем небольшую программу. Это простой цикл, выводящий в консоль числа от 1 до 10.

x = 1 while x <= 10: (x) x = x+1

Как вы можете заметить, тело цикла выполняется, пока x меньше или равно 10. Если вы присвоите x значение 20, то цикл не запустится вообще.

Вывод будет следующим:

1 2 3 4 5 6 7 8 9 10

Цикл do-while

Есть две вариации цикла while. Первая – непосредственно сам while, вторая – do-while. Разница заключается в том, что do-while запустится хотя бы один раз.

Цикл while может не запуститься вообще, если условие не будет истинным изначально. Do-while – напротив. Тут сначала выполняется тело цикла, и только потом происходит проверка условия.

Цикл do-while реализован в большинстве языков программирования, но в Python такого оператора нет. Тем не менее, его можно с легкостью имитировать – например, с помощью функций.

Давайте напишем код, имитирующий цикл do-while. Все нужные инструкции мы поместим внутри функции.

x = 20 def run_commands(x): (x) run_commands(x) x += 1 while x <= 10: run_commands(x) x += 1

Эта программа запускает run_commands() еще до цикла while. Но сам цикл while не запустится: x равен 20.

Оператор else

Если вы хотите выполнить блок кода, когда проверка условия возвращает False, – добавьте оператор else.

Добавим в наш код else. Внутри этого блока напишем код, который будет выводить в консоль Готово. Выполнится этот блок только после того, как в консоль выведутся числа от 1 до 10.

x = 1 while x <= 10: (x) x = x + 1 else: (“Готово”)

Эта программа выведет в консоль числа от 1 до 10. Как только x станет равно 11, результатом проверки условия будет False. После этого выполнится блок кода else.

Однострочное объявление while

Если внутри цикла while у вас только одна строка – можно воспользоваться однострочным вариантом. Делается это так:

x = 1 while x: (x)

Будьте осторожны – этот цикл бесконечный.

Бесконечные циклы

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

x = 1 while x >= 1: (x)

Этот цикл – бесконечный. Внутри цикла нет команды, которая изменяет значение x. Поэтому условие x >= 1 всегда истинно. Именно из-за этого цикл будет запускаться бесконечное количество раз.

Всегда будьте внимательны, когда создаете цикл. Небольшая ошибка – и у вас бесконечный цикл, что в конечном итоге приведет к сбою в работе программы.

Управление циклом

С циклом разобрались. Наконец мы можем перейти к операторам его управления.

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

Break

Этот оператор позволяет завершить цикл, если проверка условия возвращает True.

x = 1 while x <= 10: if x == 5: break (x) x += 1

Вывод:

1 2 3 4

Выполнение цикла прекращается, когда x становится равно 5 – даже если x больше или равно 1.

Continue

Допустим, вам нужно пропустить итерацию цикла, если выполняется какое-то условие. Но цикл вы не хотите завершать до тех пор, пока проверка его условия не вернет False.

В этом случае вам нужно использовать ключевое слово continue:

x = 1 while x <= 10: if x == 5: x += 1 continue (x) x += 1

Вывод:

1 2 3 4 6 7 8 9 10

Как видите, цикл выводит в консоль все числа от 1 до 10 кроме 5. Когда x становится равен 5, оставшаяся часть команд не выполняется, а начинается следующая итерация цикла.

Хотите больше материалов по Алгоритмам

Подписывайтесь на нас в Телеграм

Источник

Обновл. 24 Сен 2020 |

На этом уроке мы детально рассмотрим цикл while, его конструкцию, особенности и использование.

Цикл while

Цикл while является самым простым из 4-х циклов, которые есть в языке C++. Он очень похож на ветвление if/else:

while (условие)

тело цикла;

Цикл while объявляется с использованием ключевого слова while. В начале цикла обрабатывается условие. Если его значением является true (любое ненулевое значение), то тогда выполняется тело цикла.

Однако, в отличие от оператора if, после завершения выполнения тела цикла, управление возвращается обратно к while и процесс проверки условия повторяется. Если условие опять является true, то тогда тело цикла выполняется еще раз.

Например, следующая программа выводит все числа от 0 до 9:

#include <iostream>

int main()

{

int count = 0;

while (count < 10)

{

std::cout << count << ” “;

++count;

}

std::cout << “done!”;

return 0;

}

Результат выполнения программы:

0 1 2 3 4 5 6 7 8 9 done!

Рассмотрим детально эту программу. Во-первых, инициализируется переменная: int count = 0;. Условие 0 < 10 имеет значение true, поэтому выполняется тело цикла. В первом стейтменте мы выводим 0, а во втором – выполняем инкремент переменной count. Затем управление возвращается к началу цикла while для повторной проверки условия. Условие 1 < 10 имеет значение true, поэтому тело цикла выполняется еще раз. Тело цикла будет повторно выполняться до тех пор, пока переменная count не будет равна 10, только в том случае, когда результат условия 10 < 10 будет false, цикл завершится.

Тело цикла while может и вообще не выполняться, например:

#include <iostream>

int main()

{

int count = 15;

while (count < 10)

{

std::cout << count << ” “;

++count;

}

std::cout << “done!”;

return 0;

}

Условие 15 < 10 сразу принимает значение false, и тело цикла пропускается. Единственное, что выведет эта программа:

done!

Бесконечные циклы

С другой стороны, если условие цикла всегда принимает значение true, то и сам цикл будет выполняться бесконечно. Это называется бесконечным циклом. Например:

#include <iostream>

int main()

{

int count = 0;

while (count < 10) // это условие никогда не будет false

std::cout << count << ” “; // поэтому эта строка будет выполняться постоянно

return 0; // а эта строка никогда не выполнится

}

Поскольку переменная count не увеличивается на единицу в этой программе, то условие count < 10 всегда будет true. Следовательно, цикл никогда не будет завершен, и программа будет постоянно выводить 0 0 0 0 0….

Мы можем преднамеренно объявить бесконечный цикл следующим образом:

while (1) // или while (true)

{

// Этот цикл будет выполняться бесконечно

}

Единственный способ выйти из бесконечного цикла – использовать операторы return, break, goto, выбросить исключение или воспользоваться функцией exit().

Программы, которые работают до тех пор, пока пользователь не решит остановить их, иногда преднамеренно используют бесконечные циклы вместе с операторами return, break или функцией exit() для завершения цикла. Распространена такая практика в серверных веб-приложениях, которые работают непрерывно и постоянно обслуживают веб-запросы.

Счетчик цикла while

Часто нам нужно будет, чтобы цикл выполнялся определенное количество раз. Для этого обычно используется переменная в виде счетчика цикла. Счетчик цикла – это целочисленная переменная, которая объявляется с единственной целью: считать, сколько раз выполнился цикл. В вышеприведенных примерах переменная count является счетчиком цикла.

Счетчикам цикла часто дают простые имена, такие как i, j или k. Однако в этих именах есть одна серьезная проблема. Если вы захотите узнать, где в вашей программе используется счетчик цикла и воспользуетесь функцией поиска символов i, j или k, то в результате получите половину своей программы, так как i, j или k используются во многих именах. Следовательно, лучше использовать iii, jjj или kkk в качестве имен для счетчиков. Они более уникальны, их значительно проще найти, и они выделяются в коде. А еще лучше использовать «реальные» имена для переменных, например, count или любое другое имя, которое предоставляет контекст использования этой переменной.

Также для счетчиков цикла лучше использовать тип ed int. Использование uned int может привести к неожиданным результатам. Например:

#include <iostream>

int main()

{

uned int count = 10;

// Считаем от 10 к 0

while (count >= 0)

{

if (count == 0)

std::cout << “blastoff!”;

else

std::cout << count << ” “;

–count;

}

return 0;

}

Взгляните на эту программу еще раз и постарайтесь найти ошибку.

Оказывается, эта программа представляет собой бесконечный цикл. Она начинается с вывода 10 9 8 7 6 5 4 3 2 1 blastoff!, как и предполагалось, но затем «сходит с рельсов» и начинает отсчет с 4294967295. Почему? Потому что условие цикла count >= 0 никогда не будет ложным! Когда count = 0, то и условие 0 >= 0 имеет значение true, выводится blastoff, а затем выполняется декремент переменной count, происходит переполнение и значением переменной становится 4294967295. И так как условие 4294967295 >= 0 является истинным, то программа продолжает свое выполнение. А поскольку счетчик цикла является типа uned, то он никогда не сможет быть отрицательным, а так как он никогда не сможет быть отрицательным, то цикл никогда не завершится.

Правило: Всегда используйте тип ed int для счетчиков цикла.

Итерации

Каждое выполнение цикла называется итерацией (или «повтором»).

Поскольку тело цикла обычно является блоком, и поскольку этот блок выполняется по новой с каждым повтором, то любые переменные, объявленные внутри тела цикла, создаются, а затем и уничтожаются по новой. В следующем примере переменная z создается и уничтожается 6 раз:

#include <iostream>

int main()

{

int count = 1;

int result = 0; // переменная result определена здесь, поскольку она нам понадобится позже (вне тела цикла)

while (count <= 6) // итераций будет 6

{

int z; // z создается здесь по новой с каждой итерацией

std::cout << “Enter integer #” << count << ‘:’;

std::cin >> z;

result += z;

// Увеличиваем значение счетчика цикла на единицу

++count;

} // z уничтожается здесь по новой с каждой итерацией

std::cout << “The sum of all numbers entered is: ” << result;

return 0;

}

Для фундаментальных типов переменных это нормально. Для не фундаментальных типов переменных (таких как структуры или классы) это может сказаться на производительности. Следовательно, не фундаментальные типы переменных лучше определять перед циклом.

Обратите внимание, переменная count объявлена вне тела цикла. Это важно и необходимо, поскольку нам нужно, чтобы значение переменной сохранялось на протяжении всех итераций (не уничтожалось по новой с каждым повтором цикла).

Иногда нам может понадобиться выполнить что-то при достижении определенного количества итераций, например, вставить символ новой строки. Это легко осуществить, используя оператор остатка от деления со счетчиком цикла:

#include <iostream>

int main()

{

int count = 1;

while (count <= 50)

{

// Выводим числа до 10 (перед каждым числом добавляем 0)

if (count < 10)

std::cout << “0” << count << ” “;

else

std::cout << count << ” “; // выводим остальные числа

// Если счетчик цикла делится на 10 без остатка, то тогда вставляем символ новой строки

if (count % 10 == 0)

std::cout << “n”;

// Увеличиваем значение счетчика цикла на единицу

++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

Вложенные циклы while

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

#include <iostream>

int main()

{

int outer = 1;

while (outer <= 5)

{

int inner = 1;

while (inner <= outer)

std::cout << inner++ << ” “;

// Вставляем символ новой строки в конце каждого ряда

std::cout << “n”;

++outer;

}

return 0;

}

Результат выполнения программы:

1 2

1 2 3

1 2 3 4

1 2 3 4 5

Тест

Задание №1

Почему в программе, приведенной выше, переменная inner объявлена внутри блока while, а не сразу после объявления переменной outer (вне блока while)?

Ответ №1

Переменная inner объявлена внутри блока while так, чтобы она была восстановлена (и повторно инициализирована значением 1) каждый раз, когда выполняется внешний цикл. Если бы переменная inner была объявлена вне внешнего цикла while, то её значение никогда не было бы сброшено до 1, или нам бы пришлось это сделать самостоятельно с помощью операции присваивания. Кроме того, поскольку переменная inner используется только внутри внешнего цикла while, то имеет смысл объявить её именно там. Помните, что переменные нужно объявлять максимально близко к их первому использованию!

Задание №2

Напишите программу, которая выводит буквы английского алфавита от a до z вместе с кодами из ASCII-таблицы.

Подсказка: Чтобы выводить символы как целые числа – используйте оператор ic_cast.

Ответ №2

#include <iostream>

int main()

{

char mychar = ‘a’;

while (mychar <= ‘z’)

{

std::cout << mychar << ” ” << ic_cast<int>(mychar) << “n”;

++mychar;

}

return 0;

}

Задание №3

Измените программу из последнего подраздела «Вложенные циклы» так, чтобы она выводила следующее:

5 4 3 2 1

4 3 2 1

3 2 1

2 1

Ответ №3

#include <iostream>

int main()

{

int outer = 5;

while (outer >= 1)

{

int inner = outer;

while (inner >= 1)

std::cout << inner– << ” “;

// Вставляем символ новой строки в конце каждого ряда

std::cout << “n”;

–outer;

}

return 0;

}

Задание №4

Теперь сделайте так, чтобы цифры выводились следующим образом (используя программу из предыдущего задания):

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

Ответ №4

#include <iostream>

int main()

{

// Цикл с 1 до 5

int outer = 1;

while (outer <= 5)

{

// Числа в рядах появляются в порядке убывания, поэтому цикл начинаем с 5 и до 1

int inner = 5;

while (inner >= 1)

{

// Первое число в любом ряде совпадает с номером этого ряда,

// поэтому числа должны выводиться только если <= номера ряда (в противном случае, выводится пробел)

if (inner <= outer)

std::cout << inner << ” “;

else

std::cout << ” “; // вставляем дополнительные пробелы

–inner;

}

// Этот ряд вывели, переходим к следующему

std::cout << “n”;

++outer;

}

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

Загрузка…

Источник