Цикл while в си: Операторы цикла в языке Си : for, while, do…while

Циклы и ветвления в языке C++

Циклы

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

Цикл с предусловием

while

Условие проверяется перед выполнением тела цикла. Если условие ложно, то цикл не выполнится.

int count = 10;
while(count > 0)      // Цикл выполняется, пока условие истинно
{
    std::cout << count << endl;
    count--;
}

Цикл с постусловием

do-while

Условие проверяется после выполнения тела цикла. Цикл выполнится как минимум один раз.

int count = 10;
do
{
    std::cout << count << endl;
    count--;
} while(count > 0)    // Цикл выполняется, пока условие истинно

Цикл

for

Цикл с заранее заданными условиями и количеством итераций.

for (int i = 0; i < 10; i++)     // Цикл от 0 до 9
{
    std::cout << i << endl;
}

В цикле for задаются три блока параметров, разделенных точкой с запятой:

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

В блоках можно использовать несколько параметров через запятую.

for (int i = 0, j = 1; i <= 5; i++, j *= i)    // Несколько параметров через запятую
{
    std::cout << i << "-" << j << ", ";
}

Любой блок оператора for может отсутствовать.

int index = 10;
for (; index > 0;)             // Указан только один блок условий
{
    cout << index << endl;
    index--;
}

Переменные, объявленные в цикле, существуют только внутри цикла. В старых версиях языка C++ переменные сохранялись после выхода из цикла.

Цикл по диапазону

В стандарте C++11 появились новые виды циклов — range-based

циклы, в которых переменная пробегает по всем значением контейнера. Контейнер должен поддерживать методы begin() и end() — это может быть vector, list, set, map и массив. Цикл по диапазону не дает возможности узнать индекс текущего элемента, так как в большинстве контейнеров не существует индекса, как такового.

int arr[] = { 1, 2, 3, 4, 5};
for (int elem : arr)
{
    std::cout << elem << ' ';   // 1 2 3 4 5
}

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

int arr[] = { 1, 2, 3, 4, 5};
for (int &elem : arr)
{
    elem *= 2;
    std::cout << elem << ' ';   // 2 4 6 8 10
}

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

Прервать выполнение цикла можно с помощью команды break

for (int i = 0; i < 10; i++)
{
    std::cout << i << endl;  // Команда выполнится один раз
    break;                   // Выход из цикла
}

С помощью команды continue можно сразу перейти к следующей итерации цикла

for (int i = 0; i < 10; i++)
{
    continue;                // Переход к следующей итерации цикла
    std::cout << i << endl;  // Команда никогда не выполнится
}

Ветвления

Ветвления позволяют выполнять различные участки кода в зависимости от заданных условий.

Конструкция

if—else

Оператор if позволяет выполнить блок кода, если условие истинно.

if (a > 3)
{
    cout << "число больше 3" << endl;
}

Оператор if-else позволяет выполнить первый блок кода, если условие истинно, и второй блок, если условие ложно.

if (a % 2 == 0)
{
    cout << "четное" << endl;
}
else
{
    cout << "нечетное" << endl;
}

Однострочные блоки можно указывать без фигурных скобок

if (a % 2 == 0)
    cout << "четное" << endl;
else
    cout << "нечетное" << endl;

Последовательное указание условий можно сделать через конструкцию else if.

if (x > 5)
    cout << "X больше 5" << endl;
else if (x < 5)
    cout << "X меньше 5" << endl;
else
    cout << "X равен 5" << endl;

Конструкция

switch. ..case

Блоки кода выполняются в зависимости от указанных значений

switch (x)
{
case 1:
    cout << "X равен 1" << endl;
    break;
case 2:
    cout << "X равен 2" << endl;
    break;
}

Если в блоке не указан break, то будет выполнен следующий блок

 
switch (x)
{
case 1:
    cout << "X равен 1" << endl;
    break;
case 2:
case 3:
    cout << "X равен 2 или 3" << endl;
    break;
}

Может быть указан блок defaul, выполняющийся если ни одно из значений не подошло

switch (x)
{
case 1:
    cout << "X равен 1" << endl;
    break;
case 2:
    cout << "X равен 2" << endl;
    break;
default:
    cout << "X не равен 1 и 2" << endl;
    break;
}

В блоке case может объявляться переменная без инициализации

switch (x)
{
case 1:
    int a;     // объявление переменной
    a = 1;     // присваивание значения
    break;
case 2:
    a = 2;     // переменная видна, если она объявлена в блоке выше
    break;
default:
    break;
}

Если требуется объявить и инициализировать переменные внутри блока

case, то можно использовать вложенный блок кода

switch (x)
{
case 1:
{
    int a = 1;   // объявление и инициализация переменной
    break;
}
case 2:
    int a;       // переменная, объявленная во вложенном блоке выше, здесь не видна
    a = 2;
    break;
default:
    break;
}

 

 

 

 

 

 

7.

7 – Введение в циклы и инструкции while

Добавлено 29 мая 2021 в 13:05

Введение в циклы

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

Например, предположим, что вы хотите вывести все числа от 1 до 10. Без циклов вы можете попробовать что-то вроде этого:

#include <iostream>
 
int main()
{
    std::cout << "1 2 3 4 5 6 7 8 9 10";
    std::cout << " done!";
    return 0;
}

Хотя это выполнимо, но всё усложняется, когда вы хотите напечатать больше чисел: что, если вы хотите напечатать все числа от 1 до 1000? А это совсем немного! Но такую программу возможно написать, потому что во время компиляции мы знаем, сколько чисел мы хотим напечатать.

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

Инструкции

while

Инструкция while (также называемая

циклом while) является самым простым из трех типов циклов, предоставляемых C++, и имеет определение, очень похожее на определение оператора if:

while (условие)
    инструкция;

Инструкция while объявляется с помощью ключевого слова while. При выполнении инструкции while вычисляется условие. Если условие истинно, выполняется связанная инструкция.

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

Давайте посмотрим на простой цикл while, который выводит все числа от 1 до 10:

#include <iostream>
 
int main()
{
    int count{ 1 };
    while (count <= 10)
    {
        std::cout << count << ' ';
        ++count;
    }
 
    std::cout << "done!";
 
    return 0;
}

Эта программа выводит:

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

Давайте подробнее рассмотрим, что делает эта программа. Сначала счетчик count инициализируется значением 1, которое является первым числом, которое мы напечатаем. Условие count <= 10 истинно, поэтому инструкция выполняется. В этом случае наша инструкция – это блок, поэтому все инструкции в этом блоке будут выполнены. Первая инструкция в блоке печатает 1 и пробел, а вторая увеличивает count до 2. Теперь управление возвращается к началу оператора while, и снова вычисляется условие. 2 <= 10 вычисляется как true, поэтому блок кода выполняется снова. Цикл будет повторяться до тех пор, пока

count не станет равен 11, после чего значение 11 <= 10 будет ложным, и инструкция, связанная с циклом, будет пропущена. На этом выполнение цикла заканчивается.

Хотя эта программа представляет собой немного больше кода, чем набор всех чисел от 1 до 10, подумайте, насколько легко было бы изменить эту программу для печати всех чисел от 1 до 1000: всё, что вам нужно сделать, это изменить count <= 10 на count <= 1000.

Инструкции

while, которые изначально вычисляются как ложные

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

#include <iostream>
 
int main()
{
    int count{ 15 };
    while (count <= 10)
    {
        std::cout << count << ' ';
        ++count;
    }
 
    std::cout << "done!";
 
    return 0;
}

Условие 15 <= 10 вычисляется как false, поэтому связанная инструкция пропускается. Программа продолжается, и единственное, что будет напечатано – это «done!».

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

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

#include <iostream>
 
int main()
{
    int count{ 1 };
    while (count <= 10) // это условие никогда не будет ложным
    {
        std::cout << count << ' '; // поэтому эта строка будет выполняться многократно
    }
 
    return 0; // эта строка никогда не будет выполнена
}

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

Преднамеренные бесконечные циклы

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

while (true)
{
  // этот цикл будет выполняться вечно
}

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

Вот глупый пример, демонстрирующий это:

#include <iostream>
 
int main()
{
 
    while (true) // бесконечный цикл
    {
        std::cout << "Loop again (y/n)? ";
        char c{};
        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 <iostream>
 
int main()
{
    unsigned 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 истинно. Затем выполняется --count, и count переходит к 4294967295 (предполагается, что int занимает 32 бита). И поскольку 4294967295 >= 0 истинно, программа продолжается. Поскольку count не имеет знака, он никогда не может быть отрицательным, а поскольку он никогда не может быть отрицательным, цикл не завершится.

Лучшая практика

---

Переменные цикла должны иметь тип (signed) int.

Выполнение чего-то при каждой N-ой итерации

Каждый раз, когда цикл выполняется, это называется итерацией.

Часто мы хотим делать что-то на каждой 2-й, 3-й или 4-й итерации, например, выводить символ новой строки. Это легко сделать с помощью оператора взятия остатка от деления для нашего счетчика:

#include <iostream>
 
// Перебираем все числа от 1 до 50
int main()
{
    int count{ 1 };
    while (count <= 50)
    {
        // выводим число (для форматирования добавляем 0 перед числами меньше 10)
        if (count < 10)
        {
            std::cout << '0';
        }
 
        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

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

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

#include <iostream>
 
// Цикл от 1 до 5
int main()
{
    int outer{ 1 };
    while (outer <= 5)
    {
        // цикл от 1 до outer
        int inner{ 1 };
        while (inner <= outer)
        {
            std::cout << inner << ' ';
            ++inner;
        }
 
        // выводим символ новой строки в конце каждой строки
        std::cout << '\n';
        ++outer;
    }
 
    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 <iostream>
 
int main()
{
    char myChar{ 'a' };
    while (myChar <= 'z')
    {
        std::cout << myChar << ' ' << static_cast<int>(myChar) << '\n';
        ++myChar;
    }
 
    return 0;
}

---

Вопрос 3

Инвертируйте пример вложенных циклов, чтобы он напечатал следующее:

5 4 3 2 1
4 3 2 1
3 2 1
2 1
1

Ответ

#include <iostream>
 
// Цикл от 5 до 1
int main()
{
	int outer{ 5 };
	while (outer >= 1)
	{
		// цикл от inner до 1
		int inner{ outer };
		while (inner >= 1)
        {
			std::cout << inner-- << ' ';
        }
 
		// выводим символ новой строки в конце каждой строки
		std::cout << '\n';
		--outer;
	}
 
	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 <iostream>
 
int main()
{
	// Есть 5 строк, мы можем выполнять цикл от 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;
	}
 
	return 0;
}

Оригинал статьи:

• 7. 7 — Intro to loops and while statements

Теги

C++ / CppLearnCppwhileДля начинающихОбучениеПрограммированиеЦикл

Назад

Оглавление

Вперед

7.7 — Введение в циклы и операторы while — Изучение C++

Введение в циклы

А теперь начинается самое интересное — в следующем наборе уроков мы рассмотрим циклы. Циклы — это конструкции потока управления, которые позволяют фрагменту кода выполняться многократно, пока не будет выполнено какое-либо условие. Циклы добавляют значительную гибкость вашему программному инструментарию, позволяя делать многие вещи, которые в противном случае были бы затруднительны.

Допустим, вы хотите напечатать все числа от 1 до 10. Без циклов вы можете попробовать что-то вроде этого:

 #include 
основной ()
{
    std::cout << "1 2 3 4 5 6 7 8 9 10";
    std::cout << " готово!\n";
    вернуть 0;
} 

Хотя это выполнимо, становится все меньше, так как вы хотите напечатать больше чисел: что, если вы хотите напечатать все числа от 1 до 1000? Это было бы совсем немного печатать! Но такая программа доступна для записи таким образом, потому что во время компиляции мы знаем, сколько чисел мы хотим напечатать.

Теперь немного изменим параметры. Что, если мы хотим попросить пользователя ввести число, а затем вывести все числа от 1 до числа, которое ввел пользователь? Число, которое введет пользователь, неизвестно во время компиляции. Итак, как мы можем решить эту проблему?

Операторы while

Оператор while (также называемый циклом while) является простейшим из трех типов циклов, предоставляемых C++, и его определение очень похоже на определение оператора if :

 while (условие)
    заявление;
 

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

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

Давайте рассмотрим простой цикл while, который печатает все числа от 1 до 10:

 #include 
основной ()
{
    целое число { 1 };
    пока (количество <= 10)
    {
        std::cout << количество << ' ';
        ++количество;
    }
    std::cout << "Готово!\n";
    вернуть 0;
} 

Выводит:

 1 2 3 4 5 6 7 8 9 10 готово!
 

Давайте подробнее рассмотрим, что делает эта программа. Во-первых, count инициализируется как 1 , это первое число, которое мы напечатаем. Условие count <= 10 равно true , поэтому инструкция выполняется. В этом случае наш оператор является блоком, поэтому все операторы в блоке будут выполняться. Первый оператор в блоке печатает 1 и пробел, а второй увеличивает подсчитывает до 2. Теперь управление возвращается к началу оператора while , и условие оценивается снова. 2 <= 10 оценивается как true, поэтому блок кода выполняется снова. Цикл будет повторяться до тех пор, пока count не станет 11 , после чего 11 <= 10 будет оцениваться как false , и оператор, связанный с циклом, будет пропущен. На этом петля сделана.

Хотя эта программа представляет собой немного больше кода, чем ввод всех чисел от 1 до 10, подумайте, как легко было бы изменить программу, чтобы она печатала все числа от 1 до 1000: все, что вам нужно сделать, это изменить количество <= 10 до количество <= 1000 .

Операторы While, которые изначально оцениваются как ложные

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

 #include 
основной ()
{
    число {15};
    пока (количество <= 10)
    {
        std::cout << количество << ' ';
        ++количество;
    }
    std::cout << "Готово!\n";
    вернуть 0;
} 

Условие 15 <= 10 оценивается как false , поэтому соответствующий оператор пропускается. Программа продолжается, и единственное, что напечатано, это сделано! .

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

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

 #include 
основной ()
{
    целое число { 1 };
    while (count <= 10) // это условие никогда не будет ложным
    {
        std::cout << количество << ' '; // поэтому эта строка будет многократно выполняться
    }
    std::cout << '\n'; // эта строка никогда не будет выполнена
    вернуть 0; // эта строка никогда не будет выполнена
} 

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

Преднамеренные бесконечные циклы

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

 while (true)
{
  // этот цикл будет выполняться вечно
} 

Единственный способ выйти из бесконечного цикла — использовать оператор return, оператор break, оператор выхода, оператор goto, выбрасываемое исключение или пользователь, убивающий программу.

Вот глупый пример, демонстрирующий это:

 #include 
основной ()
{
    while (true) // бесконечный цикл
    {
        std::cout << "Повторить цикл (д/н)?";
        символ с{};
        std::cin >> c;
        если (с == 'п')
            вернуть 0;
    }
    вернуть 0;
} 

Эта программа будет непрерывно зацикливаться до тех пор, пока пользователь не введет n в качестве входных данных, после чего оператор if будет оцениваться как true и соответствующие вернуть 0; вызовет выход из функции main() , что приведет к завершению программы.

Такой цикл часто встречается в приложениях веб-сервера, которые работают непрерывно и обслуживают веб-запросы.

Лучшая практика

Используйте while(true) для преднамеренных бесконечных циклов.

Переменные цикла

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

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

Переменные цикла должны быть подписаны

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

 #include 
основной ()
{
    количество беззнаковых целых чисел { 10 };
    // считать от 10 до 0
    в то время как (количество >= 0)
    {
        если (количество == 0)
        {
            std::cout << "взрыв!";
        }
        еще
        {
            std::cout << количество << ' ';
        }
        --считать;
    }
    std::cout << '\n';
    вернуть 0;
} 

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

Оказывается, эта программа представляет собой бесконечный цикл. Он начинается с печати 10 9 8 7 6 5 4 3 2 1 старт! по желанию, но потом сходит с рельсов и начинает обратный отсчет с 4294967295 . Почему? Потому что условие цикла count >= 0 никогда не будет ложным! Когда count равен 0 , 0 >= 0 верно. Затем выполняется --count , и count возвращается к 4294967295 (при условии, что 32-битные целые числа). И поскольку 4294967295 >= 0 верно, программа продолжается. Потому что считает не имеет знака, оно никогда не может быть отрицательным, а поскольку оно никогда не может быть отрицательным, цикл не завершится.

Лучшая практика

Переменные цикла должны быть типа (со знаком) int.

Делать что-то каждые N итераций

Каждый раз, когда выполняется цикл, он называется итерацией.

Часто нам нужно что-то делать каждую 2-ю, 3-ю или 4-ю итерацию, например, печатать новую строку. Это легко сделать с помощью оператора модуля на нашем счетчике:

 #include 
// Перебираем все числа от 1 до 50
основной ()
{
    целое число { 1 };
    пока (количество <= 50)
    {
        // напечатать число (номера до 10 с начальным 0 для целей форматирования)
        если (количество < 10)
        {
            std::cout << '0';
        }
        std::cout << количество << ' ';
        // если переменная цикла делится на 10, вывести новую строку
        если (количество% 10 == 0)
        {
            std::cout << '\n';
        }
            
        // увеличиваем счетчик циклов
        ++количество;
    }
    вернуть 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
    внутренний { 1 };
    пока (внешний <= 5)
    {
        // Для каждой итерации внешнего цикла код в теле цикла выполняется один раз
        // внутренние циклы между 1 и внешним
        интервал внутренний { 1 };
        в то время как (внутренний <= внешний)
        {
            std::cout << внутренний << ' ';
            ++внутренний;
        }
        // печать новой строки в конце каждой строки
        std::cout << '\n';
        ++внешний;
    }
    вернуть 0;
} 

Эта программа печатает:

 1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
 

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

Рассмотрим подробнее, как это работает.

Во-первых, у нас есть внешний цикл (с переменной цикла external ), который зациклится 5 раз (с external , имеющим значения 1 , 2 , 3 , 4 и 5 последовательно).

На первой итерации внешнего цикла external имеет значение 1 , после чего выполняется тело внешнего цикла. Внутри тела внешнего цикла у нас есть еще один цикл с переменной цикла inner . Внутренний цикл повторяется от 1 до внешнего (который имеет значение 9).0017 1 ), поэтому этот внутренний цикл выполнится один раз и выведет значение 1 . Затем мы печатаем новую строку и увеличиваем external до 2 .

На второй итерации внешнего цикла external имеет значение 2 , после чего выполняется тело внешнего цикла. Внутри тела внешнего цикла inner выполняет итерацию от 1 до external (которое теперь имеет значение 2 ), поэтому этот внутренний цикл будет выполняться дважды, выводя значения 1 и 2 . Затем мы печатаем новую строку и увеличиваем external до 3 .

Этот процесс продолжается, внутренний цикл печатает 1 2 3 , 1 2 3 4 и 1 2 3 4 5 при последовательных проходах. В конце концов, external увеличивается до 6 , и поскольку условие внешнего цикла ( external <= 5 ) становится ложным, внешний цикл завершается. Затем программа заканчивается.

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

Время викторины

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

Показать решение

Напишите программу, которая выводит буквы от a до z вместе с их кодами ASCII.

Показать подсказку

Показать решение

Инвертировать пример вложенных циклов, чтобы он вывел следующее:

 5 4 3 2 1
4 3 2 1
3 2 1
2 1
1
 

Показать решение

Теперь напечатайте числа следующим образом:

 1
      2 1
    3 2 1
  4 3 2 1
5 4 3 2 1
 

Подсказка: сначала придумайте, как заставить его печатать вот так:

 X X X X 1
Х Х Х 2 1
Х Х 3 2 1
Х 4 3 2 1
5 4 3 2 1
 

Show Solution

while-loop · Темы GitHub · GitHub

Вот 190 публичных репозиториев соответствует этой теме...

милан9/ 03_Python_Flow_Control

Звезда 211

адитьямангал1 / C-программирование

Звезда 11

maciekt07 / SpotifyAdBlock

Звезда 9

halilozel1903 / КотлинПример

Спонсор Звезда 5

Кишанраджпут23 / Jetbrains-Python-Проекты

Звезда 5

Сидхартхуял / базовый-cpp

Звезда 5

ашу1230 / Кодирование-Ninjas-Python-Solution

Звезда 4

Кампанафернандо / калькулятор-py

Звезда 3

ЮвраджСутар / Python-данные

Звезда 3

гкиплангат / alx-low_level_programming

Звезда 3

ЕЛ-59 / C_практика

Звезда 3

Морган Берген / CPP-Основы

Звезда 2

ксб96 / Cpp-коды

Звезда 2

Ативидадес-де-Алгоритмос / Lista06-алгоритмос

Звезда 2

ДжейхунАслан / CSharp_Основы

Звезда 2

смотреть254 / генератор четных-нечетных чисел

Звезда 2

Ативидадес-де-Алгоритмос / Exemplos-aula-Repeticao-While

Звезда 2

СердарТафрали / create_Камень-ножницы-бумага_игра

Звезда 2

santhosh-программист / Basic-C-программы

Звезда 1

анкурдхамия83 / Python-обучение

Звезда 1

Улучшить эту страницу

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