В чем ошибка если на цикле

Безусловно, наиболее часто используемой инструкцией цикла в C++ является оператор for. Оператор for (также называемый циклом for) предпочтителен, когда у нас есть очевидная переменная цикла, потому что он позволяет нам легко и кратко определять, инициализировать, тестировать и изменять значение переменных цикла.

Начиная с C++11, существует два разных типа циклов for. В этом уроке мы рассмотрим классический оператор for, а новый оператор for на основе диапазона в следующем уроке (10.19 – Циклы for-each), как только рассмотрим некоторые другие необходимые темы, такие как массивы и итераторы.

Оператор for абстрактно выглядит довольно просто:

for (инструкция_инициализации; условие; конечное_выражение)
   инструкция;

Самый простой способ изначально понять, как работает оператор for, – это преобразовать его в эквивалентный оператор while:

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

Вычисление операторов for

Оператор for вычисляется в трех частях:

1. Сначала выполняется инструкция инициализации. Это происходит только один раз при запуске цикла. Инструкция инициализации обычно используется для определения и инициализации переменных. Эти переменные имеют «область видимости цикла», которая на самом деле является формой области видимости блока, где эти переменные существуют от точки определения до конца инструкции цикла. В нашем эквивалентном цикле while вы можете видеть, что инструкция инициализации находится внутри блока, содержащего цикл, поэтому переменные, определенные в инструкции инициализации, выходят за пределы области видимости, когда блок, содержащий цикл, заканчивается.
2. Во-вторых, для каждой итерации цикла вычисляется условие. Если оно истинно, инструкция выполняется. Если оно принимает значение false, цикл завершается, и выполнение продолжается со следующей инструкции за пределами цикла.
3. Наконец, после выполнения инструкции вычисляется конечное выражение. Обычно это выражение используется для увеличения или уменьшения переменных цикла, определенных в инструкции инициализации. После того, как конечное выражение было вычислено, выполнение возвращается ко второму шагу (и условие вычисляется снова).

Давайте посмотрим на пример цикла for и обсудим, как он работает:

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

Сначала мы объявляем переменную цикла с именем count и инициализируем ее значением 1.

Во-вторых, вычисляется count <= 10, и, поскольку count равно 1, условие вычисляется как true. Следовательно, выполняется инструкция, которая выводит 1 и пробел.

Наконец, вычисляется выражение ++count, которое увеличивает значение count до 2. Затем цикл возвращается ко второму шагу.

Теперь снова вычисляется count <= 10. Поскольку count имеет значение 2, условие вычисляет значение true, поэтому цикл повторяется снова. Инструкция печатает 2 и пробел, и count увеличивается до 3. Цикл продолжает повторяться, пока в конечном итоге count не увеличится до 11, после чего count <= 10 вычисляется как false, и цикл завершается.

Следовательно, эта программа выводит следующий результат:

1 2 3 4 5 6 7 8 9 10

В качестве примера давайте преобразуем приведенный выше цикл for в эквивалентный цикл while:

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

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

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

Больше примеров циклов

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

// возвращает значение base^exponent - берегитесь переполнения!
int pow(int base, int exponent)
{
    int total{ 1 };
 
    for (int count{ 0 }; count < exponent; ++count)
        total *= base;
 
    return total;
}

Эта функция возвращает значение base^exponent (base в степени exponent).

Это цикл for с простым увеличением счетчика на 1, с циклическим увеличением count от 0 до exponent (не включительно).

• Если exponent равен 0, цикл for будет выполняться 0 раз, и функция вернет 1.
• Если exponent равен 1, цикл for выполнится 1 раз, и функция вернет 1 * base.
• Если exponent равен 2, цикл for будет выполнен 2 раза, и функция вернет 1 * base * base.

Хотя большинство циклов for увеличивают переменную цикла на 1, мы также можем уменьшать ее:

#include <iostream>
 
int main()
{
    for (int count{ 9 }; count >= 0; --count)
        std::cout << count << ' ';
 
    return 0;
}

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

9 8 7 6 5 4 3 2 1 0

В качестве альтернативы мы можем с каждой итерацией изменять значение нашей переменной цикла более чем на 1:

#include <iostream>
 
int main()
{
    for (int count{ 9 }; count >= 0; count -= 2)
    std::cout << count << ' ';
 
    return 0;
}

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

9 7 5 3 1

Ошибки на единицу

Одна из самых больших проблем, с которыми сталкиваются новички в циклах for (и других циклах, в которых используются счетчики), – это ошибки «на единицу». Ошибки «на единицу» возникают, когда цикл повторяется на один раз больше или на один раз меньше, чем это необходимо.

Например:

#include <iostream>
 
int main()
{
    // упс, мы использовали operator< вместо operator<=
    for (unsigned int count{ 1 }; count < 5; ++count)
    {
        std::cout << count << ' ';
    }
 
    return 0;
}

Эта программа должна печатать «1 2 3 4 5», но она печатает только «1 2 3 4», потому что мы использовали неправильный оператор отношения.

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

Пропущенные выражения

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

#include <iostream>
 
int main()
{
    int count{ 0 };
    for ( ; count < 10; ) // нет инструкции инициализации и конечного выражения
    {
        std::cout << count << ' ';
        ++count;
    }
 
    return 0;
}

Этот цикл for дает следующий результат:

0 1 2 3 4 5 6 7 8 9

Вместо того чтобы заставлять цикл for выполнять инициализацию и инкремент, мы сделали это вручную. В этом примере мы сделали это исключительно для учебных целей, но бывают случаи, когда необходимо не объявлять переменную цикла (потому что она у вас уже есть) или не инкрементировать ее в конечном выражении (потому что вы увеличиваете ее другим способом).

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

for (;;)
    инструкция;

Приведенный выше пример эквивалентен следующему коду:

while (true)
    инструкция;

Это может показаться немного неожиданным, поскольку вы, вероятно, ожидаете, что пропущенное условное выражение будет обрабатываться как ложное. Однако стандарт C++ явно (и непоследовательно) определяет, что пропущенное условное выражение в цикле for должно рассматриваться как истинное.

Мы рекомендуем полностью избегать этой формы цикла for и вместо нее использовать while (true).

Циклы for с несколькими счетчиками

Хотя циклы for обычно выполняют итерацию только по одной переменной, иногда они должны работать с несколькими переменными. Для этого программист может определить несколько переменных в операторе инициализации, а в конечном выражении может использовать оператор запятой для изменения значений нескольких переменных:

#include <iostream>
 
int main()
{
    for (int x{ 0 }, y{ 9 }; x < 10; ++x, --y)
        std::cout << x << ' ' << y << 'n';
 
    return 0;
}

Этот цикл определяет и инициализирует две новые переменные: x и y. Он выполняет итерацию по x в диапазоне от 0 до 9, и после каждой итерации x увеличивается, а y уменьшается.

Эта программа дает следующий результат:

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

Это почти единственное место в C++, где определение нескольких переменных в одном инструкции и использование оператора запятой считается приемлемой практикой.

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

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

#include <iostream>
 
int main()
{
	for (char c{ 'a' }; c <= 'e'; ++c) // внешний цикл для букв
	{
		std::cout << c; // сначала печатаем нашу букву
		
		for (int i{ 0 }; i < 3; ++i)  // внутренний цикл для всех чисел
			std::cout << i;
 
		std::cout << 'n';
	}
 
	return 0;
}

При каждой итерации внешнего цикла внутренний цикл выполняется полностью. Следовательно, на выходе получается:

a012
b012
c012
d012
e012

Вот еще несколько подробностей о том, что здесь происходит. Сначала выполняется внешний цикл, и char c инициализируется значением 'a'. Затем вычисляется c <= 'e', что верно, поэтому выполняется тело цикла. Поскольку c установлен в 'a', сначала выводится a. Затем полностью выполняется внутренний цикл (который выводит 0, 1 и 2). Затем печатается символ новой строки. Теперь тело внешнего цикла завершено, поэтому внешний цикл возвращается наверх, c увеличивается до 'b', и условие цикла повторно вычисляется. Поскольку условие цикла по-прежнему выполняется, начинается следующая итерация внешнего цикла. Это напечатает «b012n«. И так далее.

Заключение

Операторы for – это наиболее часто используемый цикл в языке C++. Несмотря на то, что его синтаксис обычно немного сбивает с толку начинающих программистов, вы будете видеть циклы for так часто, что поймете их в кратчайшие сроки!

Операторы for идеально подходят, если у вас есть переменная-счетчик. Если у вас нет счетчика, вероятно, лучше выбрать оператор while.

Небольшой тест

Вопрос 1

Напишите цикл for, который печатает каждое четное число от 0 до 20.

Ответ

Вопрос 2

Напишите функцию с именем sumTo(), которая принимает целочисленный параметр с именем value и возвращает сумму всех чисел от 1 до value.

Например, sumTo(5) должна вернуть 15, что равно 1 + 2 + 3 + 4 + 5.

Подсказка: при итерации от 1 до входного значения используйте переменную, объявленную вне цикла, для накопления суммы, подобно тому, как в приведенном выше примере pow() используется переменная total для накопления на каждой итерации возвращаемого значения.

Ответ

Вопрос 3

Что не так со следующим циклом for?

// Вывести все числа от 9 до 0
for (unsigned int count{ 9 }; count >= 0; --count)
    std::cout << count << ' ';

Ответ

Теги

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

Содержание:развернуть

• Немного информатики
• Синтаксис цикла while
• Несколько примеров использования цикла while
• break и continue
• else
• while true или бесконечный цикл
• Best practice

• Цикл while в одну строку

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

• Как выйти с помощью break из двух циклов

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

Циклы в языке Python представлены двумя основными конструкциями: while и for. Цикл while считается универсальным, в то время как for нужен для обхода последовательности поэлементно.

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

Немного информатики

Как было отмечено выше,

Цикл — это управляющая конструкция, которая раз за разом выполняет серию команд (тело цикла) до тех пор, пока условие для выполнения является истинным.

Напишем на псевдокоде классическую схему:

повторять, пока условие
начало цикла
последовательность инструкций
конец цикла

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

Циклы, как механизм программирования, нужны, главным образом, для упрощения написания кода. Вполне очевидно, что создавать программу, выполняющую определённую операцию для каждой точки 4К дисплея в отсутствии циклов — это вручную повторять описание нужной команды 4096*2160 раз. 🤔 Много? Безусловно.

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

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

Синтаксис цикла while

В самом простом случае, цикл while в python очень похож по своей структуре на условную конструкцию с if:

import time
a = 1

while a == 1:
print("I'm the loop")
time.sleep(1)

И в том и в другом случае, блок кода внутри (инструкция print(‘…’)) будет исполнен тогда и только тогда, когда условие (a == 1) будет иметь значение True. Вот только в конструкции с if, при успешной проверке, вывод на экран будет выполнен всего один раз, а в случае с while фраза «I’m the loop» будет печататься бесконечно.

Такое явление называется бесконечным циклом. У них есть свои определенные смысл и польза, но их мы разберём чуть позже, поскольку чаще всего цикл всё-таки должен как-то заканчиваться. И вполне логично, что для его завершения нужно произвести определенные манипуляции с условием.

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

count = 1 # фиксируем начальное значение
while count <= 10: # и конечное (включительно)
print(count, end=' ')
count += 1

# после 9-й итерации в count будет храниться значение 10
# это удовлетворяет условию count <= 10, поэтому на 10-м витке будет выведено число 10
# (как видно, значение счетчика печатается до его инкрементирования)
# после count станет равным 11, а, значит, следующий прогон цикла не состоится, и он будет прерван
# в итоге получаем:
> 1 2 3 4 5 6 7 8 9 10

В Python есть и более сложные, составные условия. Они могут быть сколь угодно длинными, а в их записи используются логические операторы (not, and, or):

dayoff = False
sunrise = 6
sunset = 18

>
You have 6 hours to work
You have 5 hours to work
You have 4 hours to work
You have 3 hours to work
You have 2 hours to work
You have 1 hours to work
Finally it's over!

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

num = 0
control = True
while num < 10:
num += 1

# аналогичная запись
num = 0
control = True
while control:
if num == 10:
control = False
num += 1

Стоит иметь в виду, что использование неинициализированной переменной в качестве управляющей цикла обязательно приведёт к возникновению ошибки:

# unknown до этого нигде не была объявлена
while unknown:
print('+')

>
Traceback (most recent call last):
while unknown:
NameError: name 'unknown' is not defined

Несколько примеров использования цикла while

Идея циклов while проста — требуется определенное количество раз сделать что-то? Заведи счётчик и уменьшай/увеличивай его в теле цикла.

x = 20
y = 30
while x < y:
print(x, end=' ')
x = x + 3

> 20 23 26 29

Своеобразным счётчиком может быть даже строка:

word = "pythonchik"
while word:
print(word, end=" ")
# на каждой итерации убираем символ с конца
word = word[:-1]

> pythonchik pythonchi pythonch pythonc python pytho pyth pyt py p

break и continue

Оператор break заставляет интерпретатор прервать выполнение цикла и перейти к следующей за ним инструкции:

counter = 0
while True:
if counter == 10:
break
counter += 1

Цикл прервётся после того, как значение счетчика дойдёт до десяти.

Существует похожий оператор под названием continue, однако он не прекращает выполнение всей конструкции, а прерывает лишь текущую итерацию, переходя затем в начало цикла:

# классический пример вывода одних лишь чётных значений
z = 10
while z:
z -= 1
if z % 2 != 0:
continue
print(z, end=" ")

> 8 6 4 2 0

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

else

В Python-циклах часть else выполняется лишь тогда, когда цикл отработал, не будучи прерван break-ом.

В реальной практике, else в циклах применяется нечасто. Такая конструкция отлично сработает, когда будет необходимо проверить факт выполнения всех итераций цикла.

👉 Пример из практики: проверка доступности всех выбранных узлов сети

Например, обойти все узлы локальной сети и

def print_prime_list(list_of_numbers: list) -> None:
""" функция выведет список чисел,
если каждое из этих чисел является простым """
number_count = len(list_of_numbers) # количество чисел

print_prime_list([11, 113, 199])
> [11, 113, 199]

В каком-либо другом языке стоило бы завести булеву переменную, в которой хранится результат проверки, но у Python, как всегда, есть способ получше!

while true или бесконечный цикл

В большинстве случаев, бесконечные циклы появляются из-за логических ошибок программиста (например, когда условие цикла while при любых вариантах равно True). Поэтому следует внимательно следить за условием, при котором цикл будет завершаться.

Однако вы некоторых случая бесконечный цикл делают намерено:

1. Если нужно производить какие-то действия с интервалом, и выходить из цикла лишь в том случае, когда внутри тела «зашито» условие выхода.
   Пример: функция, которая возвращает connection базы данных. Если связь с базой данных отсутствует, соединение будет пытаться (в цикле) установиться до тех пор, пока не установится.
2. Если вы пишете полноценный демон, который продолжительное время висит как процесс в системе и периодически производит какие-то действия. В таком случае остановкой цикла будет прерывание работы программы. Пример: скрипт, который раз в 10 минут «пингует» IP адреса и пишет в лог отчет о доступности этих адресов.

💁‍♂️ Совет: в бесконечных циклах рекомендуется ставить таймаут выполнения после каждой итерации, иначе вы очень сильно нагрузите CPU:

import time

Aborted!

Код был прерван комбинацией клавиш ^Ctrl + C. Иначе цикл продолжался бы бесконечно.

Best practice

Цикл while в одну строку

Для составных конструкций (таких, где нужен блок с отступом), можно этот отступ убрать, но только если в блоке используются простые операторы. Отделяются они всё также двоеточием.

Например, записи:

while x < y:
x +=1

while x < y: x += 1

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

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

Вложенные while циклы встречаются не так часто, как их братья (или сестры) for, что, однако не мешает им быть полезными. Простой пример — выведем на экран таблицу умножения:

q = 1
while q <= 9:
w = 1
while w <= 9:
print(q * w, end=" ")
w += 1
q += 1
print("")

>
1 2 3 4 5 6 7 8 9
2 4 6 8 10 12 14 16 18
3 6 9 12 15 18 21 24 27
4 8 12 16 20 24 28 32 36
5 10 15 20 25 30 35 40 45
6 12 18 24 30 36 42 48 54
7 14 21 28 35 42 49 56 63
8 16 24 32 40 48 56 64 72
9 18 27 36 45 54 63 72 81

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

Как выйти с помощью break из двух циклов

В случае вложенных циклов, оператор break завершает работу только того цикла, внутри которого он был вызван:

i = 100
j = 200
while i < 105:
while j < 205:
if j == 203:
break
print('J', j)
j += 1
print('I', i)
i += 1

>
J 200
J 201
J 202
# здесь видно, что внутренний цикл прерывается, но внешний продолжает работу
I 100
I 101
I 102
I 103
I 104

В Python не существует конструкций, которая прерывала бы сразу несколько циклов. Но есть как минимум 3 способа, которыми можно реализовать данное поведение:

Способ №1
Используем конструкцию for ... else ...:

def same_values_exists(list_1: list, list_2: list) -> None:
""" функция выводит на экран
первые совпавшие числа из списков """
for i in list_1:
for j in list_2:
print("compare: ", i, j)
if i == j:
print(f"found {i}")
break
else:
continue
break

same_values_exists([0, 10, -2, 23], [-2, 2])
>
compare: 0 -2
compare: 0 2
compare: 10 -2
compare: 10 2
compare: -2 -2
found -2

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

Способ №2
Через создание дополнительного флага:

def same_values_exists(list_1: list, list_2: list) -> None:
""" функция выводит на экран
первые совпавшие числа из списков """
break_the_loop = False

same_values_exists([0, 10, -2, 23], [-2, 2])
>
compare: 0 -2
compare: 0 2
compare: 10 -2
compare: 10 2
compare: -2 -2
found -2

Внешний цикл был прерван вслед за внутренним. Дело сделано!

Способ №3
Если циклы находятся в функции (как в нашем примере), достаточно просто сделать return:

def same_values_exists(list_1: list, list_2: list) -> None:
""" функция выводит на экран
первые совпавшие числа из списков """
for i in list_1:
for j in list_2:
print("compare: ", i, j)
if i == j:
print(f"found {i}")
return

>
compare: 0 -2
compare: 0 2
compare: 10 -2
compare: 10 2
compare: -2 -2
found -2

—