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

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

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

Например, предположим, что вы хотите вывести все числа от 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(), завершив программу.

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

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

Часто нам нужно, чтобы цикл выполнялся определенное количество раз. Для этого обычно используется переменная цикла, часто называемая счетчиком. Переменная цикла – это целочисленное значение, которое используется для подсчета количества выполнений цикла. В приведенных выше примерах переменной цикла является переменная 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 не имеет знака, он никогда не может быть отрицательным, а поскольку он никогда не может быть отрицательным, цикл не завершится.

Выполнение чего-то при каждой 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?

Ответ

Вопрос 2

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

Подсказка

Ответ

Вопрос 3

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

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

Ответ

Вопрос 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

Ответ

Теги