Написать цикл while в c

Циклы

Последнее обновление: 19.06.2017

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

• for

• foreach

• while

• do…while

Цикл for

Цикл for имеет следующее формальное определение:

for ([инициализация счетчика]; [условие]; [изменение счетчика])
{
// действия
}

Рассмотрим стандартный цикл for:

for (int i = 0; i < 9; i++)
{
Console.WriteLine($”Квадрат числа {i} равен {i*i}”);
}

Первая часть объявления цикла – int i = 0 – создает и инициализирует счетчик i. Счетчик необязательно должен представлять тип
int. Это может быть и другой числовой тип, например, float. И перед выполнением цикла его значение будет равно 0. В данном
случае это то же самое, что и объявление переменной.

Вторая часть – условие, при котором будет выполняться цикл. Пока условное выражение возвращает true, будет выполняться цикл.
В данном случае цикл будет выполняться, пока счетчик i не достигнет 9.

И третья часть – приращение счетчика на единицу. Опять же нам необязательно увеличивать на единицу. Можно уменьшать: i–.

В итоге блок цикла сработает 9 раз, пока значение i не станет равным 9. И каждый раз это значение будет увеличиваться на 1.

Нам необязательно указывать все условия при объявлении цикла. Например, мы можем написать так:

int i = 0;
for (; 😉
{
Console.WriteLine($”Квадрат числа {++i} равен {i * i}”);
}

Формально определение цикла осталось тем же, только теперь блоки в определении у нас пустые: for (; i <;). У нас нет
инициализированной переменной-счетчика, нет условия, поэтому цикл будет работать вечно – бесконечный цикл.

Мы также можем опустить ряд блоков:

int i = 0;
for (; i<9;)
{
Console.WriteLine($”Квадрат числа {++i} равен {i * i}”);
}

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

Цикл do

В цикле do сначала выполняется код цикла, а потом происходит проверка условия в инструкции while. И пока это условие истинно,
цикл повторяется. Например:

int i = 6;
do
{
Console.WriteLine(i);
i–;
}
while (i > 0);

Здесь код цикла сработает 6 раз, пока i не станет равным нулю. Но важно отметить, что цикл do гарантирует хотя бы единократное выполнение действий,
даже если условие в инструкции while не будет истинно. То есть мы можем написать:

int i = -1;
do
{
Console.WriteLine(i);
i–;
}
while (i > 0);

Хотя у нас переменная i меньше 0, цикл все равно один раз выполнится.

Цикл while

В отличие от цикла do цикл while сразу проверяет истинность некоторого условия, и если условие истинно, то код цикла выполняется:

int i = 6;
while (i > 0)
{
Console.WriteLine(i);
i–;
}

Операторы continue и break

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

Например:

for (int i = 0; i < 9; i++)
{
if (i == 5)
break;
Console.WriteLine(i);
}

Хотя в условии цикла сказано, что цикл будет выполняться, пока счетчик i не достигнет значения 9, в реальности цикл сработает 5 раз.
Так как при достижении счетчиком i значения 5, сработает оператор break, и цикл завершится.

Теперь поставим себе другую задачу. А что если мы хотим, чтобы при проверке цикл не завершался, а просто пропускал текущую итерацию.
Для этого мы можем воспользоваться оператором continue:

for (int i = 0; i < 9; i++)
{
if (i == 5)
continue;
Console.WriteLine(i);
}

В этом случае цикл, когда дойдет до числа 5, которое не удовлетворяет условию проверки, просто пропустит это число и перейдет к следующей итерации:

Цикл foreach

Цикл foreach перебирает коллекции, например, массивы, и будет рассмотрен далее в теме массивов.

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

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

Самый часто используемый цикл — это цикл for, его структура показана ниже:

for ( /*инициализация переменной; условие; изменение значения переменной*/ ) {
// тело цикла (тут находится код который будет повторяться)
}

Инициализация переменной позволяет либо объявить переменную и присвоить ей значение либо присвоить значение уже существующей переменной. Во-вторых, значение этой переменной сообщает программе — истинно или ложно условие цикла. И пока условие цикла — истинно, цикл должен продолжать повторяться. Управляющую переменную обязательно необходимо как-то изменять, иначе цикл будет бесконечный, например можно обновлять её так: i++, i = i + 2 или даже так i = random(5). Обратите внимание, что каждую секцию в заголовке цикла, отделяет точка с запятой , что очень важно. Также отметим, что каждый из разделов может быть пустым, хотя точки с запятой все еще должны быть там. Если условие не пустое, то оно оценивается как истинное и цикл будет выполняться до тех пор, пока что-то не сделает условие цикла — ложным. Давайте рассмотрим простой пример использования цикла for.

#include <stdio.h>

int main()
{
int i;
/* Цикл будет работать до тех пор, пока i < 10, при этом после каждой итерации переменная i будет инкрементироваться(увеличиваться на 1)*/
for ( i = 0; i < 10; i++ ) {
/* Имейте ввиду что условие проверяется перед каждым повторением,
            то есть работа цикла остановится когда переменная i будет равна 10*/
printf( “%dn”, i );
}
getchar();
}

Собственно, результат работы программы:

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

Цикл while — очень простой цикл, вот его структура:

while ( /*условие*/ )
{
   // тело цикл – тут находится код, который необходимо повторять
}

Тело цикла начинает выполняться, если условие цикла — истинно. Условие представляет собой логическое выражение, например х == 1 или х! = 7 (х не равно 7). То есть условие может быть абсолютно любым — любое сочетание логических выражений. Вот пример составного условия — x == 3 || x > 10, это условие будет истинным, если икс будет равен трем или икс будет больше 10. Обратите внимание, что while имеет раздела инициализации или раздела изменения управляемой переменной, поэтому перед использованием этого цикла, сначала необходимо объявить переменную, которая будет проверяться в условии цикла и в теле цикла изменять значение этой переменной. Собственно, давайте рассмотрим простой пример с использованием цикла while:

#include <stdio.h>

int main()
{
int var = 0; /* обязательно сначала объявляем переменную */

while ( var < 10 ) { /* пока значение переменной var меньше 10 */
printf( “%dn”, var );
var++; /* обновляем значение в переменной var(если этого не делать, то условие цикла всегда будет истинным, тогда цикл будет – бесконечным) */
}
getchar();
}

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

Есть еще один тип циклов — do while. Этот цикл полезен, когда необходимо выполнить код по крайней мере — 1 раз. Рассмотрим его структуру:

do {
   // тело цикла
} while ( /*условие*/ );

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

#include <stdio.h>

int main()
{
int i = 0;

do {
/* Напечатает сообщение и завершит работу*/
printf( “Привет! Я цикл do whilen” );
} while ( i != 0 );
getchar();
}

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

Операторы break и continue

Эти два ключевых слова очень важны для циклов, они могут управлять повторениями в цикле. Оператор break делает принудительный выход из цикла, даже когда условие цикла — истинно. Оператор break удобно использовать, когда необходимо выйти из цикла при особых обстоятельствах. Оператор continue нужен если необходимо пропустить какой-то блок кода, но при этом не прекращать работу цикла. Подробно об операторах вы можете прочитать в разделе С++: статья про оператор continue, статья про оператор break.

Loading…

Оператор цикла while или цикл while — цикл, повторяющий одно и то же действие, пока условие продолжения цикла while остаётся истинным.

// форма записи цикла while
while (/*условие продолжения цикла while*/)
{
/*блок операторов*/;
/*управление условием*/;
}

Условие продолжения цикла должно быть истинно true, как только условие стало ложным, выполняется выход из цикла. Также как и в условных операторах выбора, фигурные скобочки могут опускаться в том случае, если тело цикла — это один оператор. Но как правило в цикле выполняется несколько операторов, так как кроме выполнения полезного действия необходимо делать условие цикла while ложным, иначе цикл будет бесконечным, а это, в свою очередь, приведет к зависанию программы.

Рассмотрим применение цикла while на примере движения автомобиля. На псевдокоде, то это будет так:

// Пока скорость движения автомобиля меньше 60 км/ч, продолжать наращивать скорость.

Истинным условием цикла, в данном случае, является скорость автомобиля меньше 60 км/ч, а ложным — скорость автомобиля больше или равно 60 км/ч. Повторение цикла будет продолжаться до тех пор пока скорость автомобиля не станет больше или равно 60 км/ч, после наступления этого момента условие цикла станет ложным, и программа выйдет из цикла. Рассмотрим  фрагмент кода на C++ с циклом while решающим поставленную задачу.

int speed = 5; // начальная скорость автомобиля
while ( speed < 60 ) // заголовок цикла while
speed += 10; // тело цикла

Для начала в строке 1 была объявлена и инициализирована переменная speed. В строке 2 программа проверяет условие цикла while, 5 < 60 = true. Программа входит в цикл и выполняет оператор в строке 3. Теперь уже speed = 15. Опять выполняется проверка 15 < 60 = true. Условие истинно, значение в переменной изменяется, speed = 25. Таким образом, выполняются последовательные повторения цикла, переменная speed ещё принимает такие значения: 35, 45, 55, 65. Последнее изменение переменной speed приводит к тому, что условие в цикле while  становится ложным 65 < 60 = false, и производится выход из цикла while. Таким образом, выполнилось 6 повторений, при этом speed = 65; — с таким значением переменной закончилась работа цикла while. Давайте запрограммируем эту задачу, и убедимся в достоверности всего выше сказанного.

// while.cpp: определяет точку входа для консольного приложения.

#include “stdafx.h”
#include <iostream>
using namespace std;

int main(int argc, char* argv[])
{
int speed = 5, count = 1;
while ( speed < 60 )
{
speed += 10; // приращение скорости
cout << count <<“-speed = ” << speed << endl;
count++; // подсчёт повторений цикла
}
system(“pause”);
return 0;
}

Итак, в строке 14 добавил переменную-счётчик, для подсчёта прохождений цикла. Тело цикла увеличилось, поэтому пришлось поставить фигурные скобочки. Результат работы программы (см. Рисунок 1).

Рисунок 1 — Цикл while в C++

Как я и говорил, всего 6 повторений цикла и после выхода из цикла while переменная speed = 65.

Для закрепления материала по циклу while разработаем всем известную игру «Отгадай число». На псевдокоде это будет так:

// Пока загаданное число не угадано, продолжать угадывать его

Загадывать число будет компьютер, а мы — отгадывать. Используя генератор случайных чисел, компьютер загадает число от 1 до 10, включительно, пока мы не отгадаем число выход из цикла не произойдет.

// ygadai.cpp: определяет точку входа для консольного приложения.

#include “stdafx.h”
#include <iostream>
#include <ctime>
using namespace std;

int main(int argc, char* argv[])
{
srand( time( 0 ) );
int unknown_number = 1 + rand() % 10; // загадываемое число
int enter_number; // переменная для хранения введённого числа
cout << “Enter unknown number [1:10] : “; // начинаем отгадывать
cin >> enter_number;
while ( enter_number != unknown_number )
{
cout << “Enter unknown number [1:10] : “;
cin >> enter_number; // продолжаем отгадывать
}
cout << “You win!!!n”;
system(“pause”);
return 0;
}

Чтобы войти в цикл необходимо инициализировать переменную enter_number, тогда цикл while начнёт корректную проверку условия, вот для этого перед циклом while мы запрашиваем пользователя ввести число. После того как пользователь ввёл число, начинает работать цикл while, выйти из которого получится только в случае угадывания числа. результат работы программы (см. Рисунок 2).

Рисунок 1 — Цикл while в C++

Я отгадал число с третьей попытки, а Вы, с какой сможете??