От начального до среднего уровня: Оператор FOR

Введение

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

В предыдущей статье, "От начального до среднего уровня: Оператор SWITCH", были объяснено и продемонстрировано использование оператора switch в самой базовой и простой форме. Очень важно, чтобы вы постарались понять, как работает каждый из операторов, которые мы рассматривали до сих пор. Чтобы уметь применять каждый оператор и усваивать полученные знания, материал нужно не заучивать, а понимать.

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

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

Главные понятия оператора FOR

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

По этой причине даже самые опытные программисты продолжают учиться. Они учатся и следят за новыми тенденциями постоянно. Это противоречит мнению многих начинающих изучение программирование, поскольку они склонны считать, что какие-то базовые знания уже делают их программистами, но на самом деле это не так. Старые техники необходимо постоянно изучать и совершенствовать, только так вы достигнете того уровня, который позволит вам сказать: "Я - ПРОГРАММИСТ".

Зачем я всё это говорю? Всё очень просто, с учетом всего рассмотренного, если вы решите изучать только то, что уже было показано, вы сможете решить практически любую задачу по программированию. Это связано с тем, что оператор FOR, по сути, является оператором цикла. Однако мы уже видели, как работать с циклами с помощью оператора WHILE и пары DO WHILE. Так зачем нам нужен еще один оператор для работы с циклами? В этом нет особого смысла, не так ли?

На самом деле, есть причина, по которой оператор FOR сосуществует с операторами WHILE и DO WHILE: есть ситуации, когда оператор WHILE или пара DO WHILE не подходят. Это может показаться странным, но да, есть контексты, в которых предпочтительнее использовать оператор FOR вместо операторов WHILE и DO WHILE. Многие из этих ситуаций связаны с использованием операторов CONTINUE внутри цикла.

Однако важно четко уяснить этот момент: оператор FOR является наиболее предпочтительным для программистов. Это связано с тем, что один и тот же код с его использованием понятнее и читабельнее цикла, написанного с помощью операторов WHILE или DO WHILE. Почему так происходит? Причина в том, что, как правило (и это тоже важно отметить), оператор FOR содержит все необходимые шаги для управления циклом в своем собственном операторе. Операторы WHILE и DO WHILE, напротив, распределяют управление по разным точкам цикла. Этот простой факт заставляет программистов отдавать предпочтение оператору FOR, поскольку для исправления, модификации или даже понимания цикла достаточно посмотреть на его объявление. Это гораздо проще, чем искать такие элементы внутри процедуры цикла.

Но подождите секундочку. Если было известно, что оператор FOR проще других для управления циклом, почему об этом еще не упоминалось? Не лучше ли было показать его раньше? Это несколько спорный вопрос, дорогой читатель. Хотя оператор FOR действительно проще, по крайней мере, на начальном этапе, - у него есть некоторые особенности, которые могут сделать его довольно сложным. По этой причине я решил представить операторы WHILE и DO WHILE первыми, а оператор FOR оставить напоследок.

Хотя здесь мы сначала рассмотрим оператор в его самом простом и базовом виде, мне и вам - если вы изучили предыдущие операторы - будет гораздо проще объяснить, как работает оператор FOR. Возможно, мне следовало бы отложить это объяснение, поскольку мы еще не обсудили правила старшинства для операторов. Эти правила оказывают глубокое влияние на программирование в целом. Однако, даже без объяснения этих правил, мы всё равно можем кое-что сделать с помощью операторов управления потоком. Это позволяет мне создавать контент, ориентированный на уровень начинающего программиста, на основе этих статей и официальной документации по MQL5. Это был бы идеальный сценарий. Однако, поскольку я знаю, что многие уже сталкивались с программированием, даже если они до конца не разбираются в нем, я могу создать нечто промежуточное, доступное всем.

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

Оператор FOR

Самый простой способ ввести новый оператор - это представить его на примере того, что мы уже видели. Мы сделаем следующее: на этом первом этапе мы используем скрипты, которые мы видели в статье об операторе WHILE и его партнере DO WHILE. Таким образом, переход будет более плавным и не вызовет удивления. Поэтому давайте рассмотрим этот первый контакт как перевод этих кодов в другие коды, но на этот раз с использованием исключительно оператора FOR.

Начнем с самого простого кода:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char info = 10;
07. 
08.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
09. 
10.     while (info)
11.     {
12.         info = info - 1;
13.         Print(__FUNCTION__, " : ", info);
14.     }
15. 
16.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
17. }
18. //+------------------------------------------------------------------+

Код 01

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

Получив необходимые знания, можно будет переводить код 01 для использования оператора FOR. Существует несколько способов сделать это, но каждый из них добавляет или изменяет что-то в коде. Для начала мы применим вариант, при котором код будет очень похожим на код 01. Это можно увидеть ниже:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char info = 10;
07. 
08.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
09. 
10.     for( ; info; )
11.     {
12.         info = info - 1;
13.         Print(__FUNCTION__, " : ", info);
14.     }
15. 
16.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
17. }
18. //+------------------------------------------------------------------+

Код 02

Код 02 показывает первый способ работы с оператором FOR. Обратите внимание, что мы изменили только строку 10. Однако результат одинаков как для кода 01, так и для кода 02. Данный результат можно увидеть на рисунке ниже:

Рисунок 01

Но при взгляде на код 02 можно немного растеряться. Это связано с тем, что если вы видели другие операторы FOR, то оператор в строке 10, сильно отличается от того, что обычно встречается в большинстве кодов. Именно поэтому вам необходимо усвоить знания, изложенные в предыдущих статьях. Оператор FOR - это не просто оператор. Фактически, он разделен на три части, каждая из которых имеет конкретную цель, которую вам необходимо понять досконально. Прежде чем перейти к деталям этого раздела, давайте рассмотрим вторую альтернативу для того же кода 01. Этот вариант показан ниже:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char info = 10;
07. 
08.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
09. 
10.     for( ; info; info = info - 1)
11.         Print(__FUNCTION__, " : ", info);
12. 
13.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
14. }
15. //+------------------------------------------------------------------+

Код 03

А теперь внимание. То, что вы видите в коде 03, уже не то, что было раньше. Это происходит так, потому что значение переменной info НЕ ИЗМЕНИТСЯ, как мы и ожидали. Да, оно изменится, но результат будет другим. Поэтому, после выполнения кода 03, вы получите показанный ниже результат:

Рисунок 02

Но почему результат отличается? Это немного странно, не так ли? Не могли бы мы использовать оператор FOR для создания цикла в этом случае? Ну что ж, давайте делать всё шаг за шагом. Во-первых, мы можем использовать оператор FOR для цикла, который мы строим, чтобы сохранить результат, как показано на рисунке 01. Однако именно здесь многие начинают путаться: необходимо понять важность переменной info. Потому что всё будет зависеть от нее, а не обязательно от цикла FOR. Почему я упомянул об этом? Потому что в зависимости от конкретного случая для оператора FOR необходимо использовать тот или иной метод, чтобы в коде 03 получить тот же результат, что и в коде 02. По этой причине не стоит пытаться запомнить наизусть, как с ним работать, а нужно понять, как он работает. Однако, не так просто понять, как работает оператор.

Здесь возникают сложности, и многие бросают попытки научиться использовать этот оператор. Но постараемся объяснить это как можно проще. Предположим, что переменную info надо объявить в шестой строке. Неважна причина, мы просто хотим ее определить именно так. Второй момент: мы хотим, чтобы переменная info изменялась в цикле, чтобы она выходила из цикла с определенным значением. Однако возникает небольшая проблема, которую мы пока не затронем, временно оставим наши предположения. Если проверять значение переменной info в коде 01 после того, как он пройдет через цикл, то увидим, что оно равно нулю. То же самое относится и к коду 02. Однако в коде 03 значение должно быть равно единице, но, как видно на изображении 2, первое значение равно десяти, а не девяти, как можно было бы ожидать.

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

Хорошо, мы можем просто использовать код 02 и всё, потому что он работает. Можно даже использовать код 01, который тоже работает. Но разве нет другого способа использовать оператор FOR для решения нашей проблемы? На самом деле способ есть. Однако он немного более продвинутый, чем материал, который я планирую представить в данный момент. Но я могу показать вам кое-что еще. Оно по крайней мере, приблизит результат к ожидаемому, как показано на рисунке 01.

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

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char info = 10;
07. 
08.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
09. 
10.     for(info = info - 1; info; info = info - 1)
11.         Print(__FUNCTION__, " : ", info);
12. 
13.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
14. }
15. //+------------------------------------------------------------------+

Код 04

Код 04 по-прежнему считается базовым материалом. Хотя здесь мы начинаем рассматривать другие аспекты, это всё еще базовый способ использования оператора FOR. Это необходимо для того, чтобы приведенная ниже схема имела смысл. При выполнении данного кода вы получите следующий результат:

Рисунок 03

Не понятно. Теперь мы начинаем счет с девяти, как на рисунке 01. Однако счет остановился на единице, как показано на изображении 02. Почему? Возможно значение переменной info после прохождения цикла отличается от значения, которое мы нашли бы в других кодах, прежде всего в коде 01? Нет, дорогой читатель. Значение переменной info во всех этих кодах остается нулевым после прохождения цикла, но проблема здесь в другом. Значение, которое мы выводим на печать, - это не реальное значение переменной info, а значение переменной во время конкретного взаимодействия с циклом FOR. Это может быть запутанным, но именно так и происходит. Чтобы вам стало понятнее, нам нужен немного другой код. Но прежде чем мы это сделаем, давайте посмотрим, как будет выглядеть поток выполнения внутри оператора FOR. Для этого перейдем к новой теме.

Поток выполнения

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

Рисунок 04

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

Хорошо, будем идти шаг за шагом. Первая часть - зарезервированное слово for, с которого начинается тело цикла. Сразу после этого у нас есть выражение 01. Оно может выполнять множество действий, но выполняется только один раз. Обычно мы используем его для инициализации локальных переменных внутри цикла. Однако мы также можем использовать данное выражение для настройки какого-то глобального значения, как это было сделано в коде 04. Важно отметить, что это выражение тоже может быть пустым, как в случае с кодами 02 и 03. В таких случаях компилятор просто пропускает его, не выполняя никаких дополнительных задач ни по установке, ни по объявлению переменной или значения. При объявлении переменных нужно быть осторожным, но сейчас мы остановимся только на основных: использование глобальных переменных или пустого выражения.

После выполнения выражения 01 мы переходим к следующему этапу, который на схеме представлен в виде оператора IF. В этот момент проверяется выражение 02. В некотором смысле правильнее было бы использовать не IF, а WHILE. Но, поскольку оператор WHILE - это оператор цикла, может быть непонятно, что мы имеем дело с оператором FOR, а не с оператором WHILE. В любом случае, если выражение 02 ложное, цикл FOR завершается. Если выражение 02 истинно, то выполняется процедура, содержащаяся в теле цикла. В данном случае это может быть строка 11 в кодах 03 и 04 или блок между строками 11 и 14 в коде 02. После выполнения данной процедуры выполняется выражение 03. Этот аспект особенно интересен в некоторых сценариях, как мы увидим ниже. Это связано с тем, что в зависимости от конструкции цикла и поставленной перед ним задачи, у части цикла, в которой находится выражение 03, могут быть несколько разные конструкции. Кроме того, существование выражения 03, если оно содержит что-то, что должно быть выполнено, делает цикл FOR безопаснее других типов циклов. Это связано с тем, что мы уже не рискуем забыть внести изменения в значение переменной, которая будет проверяться в выражении 02.

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

Если спокойно понаблюдать и проанализировать, то вы поймете, что логичнее, чтобы после прохождения цикла у переменной info было нулевое значение. Но также логично, что при просмотре кода 03 у значения, отображаемого на терминале, будет вид info + 1. В остальных случаях значение сильно отличается от первоначально ожидаемого.

Идем дальше. Думаю, я постепенно начинаю понимать оператор FOR. Он кажется достаточно простым, хотя иногда может быть немного запутанным. Но, между нами говоря, было упомянуто, что IF, присутствующий на схеме, должен быть оператором WHILE. Каким образом? Вы можете подумать, что эта часть не совсем понятна и ее нужно объяснить лучше. Данный вопрос - или, по крайней мере, так я его вижу - относительно прост, если не вдаваться в подробности о цикле FOR. Потому что, безусловно, есть некоторые аспекты, которые делают его сложным для новичков. Но если вы хотите понять, почему я говорю, что IF в схеме следует заменить оператором WHILE, просто посмотрите на коды 01 и 02 и сравните их. Поскольку выражения 01 и 03 пусты, единственное, что здесь осталось, - это то, что можно напрямую заменить оператором WHILE. Именно поэтому я упомянул, что IF, который показан на схеме, на самом деле должен быть оператором WHILE.

Возможно, вы не заметили, но я по мере возможности избегаю углубляться в более продвинутую модель оператора FOR. Я не хочу, чтобы первое знакомство с этим оператором отбило у вас желание понять его. Однако я также не хочу, чтобы вы думали, что оператор FOR не нужен и что его можно заменить какой-нибудь конструкцией с использованием оператора WHILE или даже парой DO WHILE, поэтому я покажу вам случай, когда этого делать нельзя. Но об этом мы поговорим в другой теме.

Пустой оператор FOR

То, что мы увидим здесь, следует рассматривать скорее как интересный момент, чем как что-то, что мы должны использовать на практике. Если честно, то, что я сейчас покажу, не часто используется в программах. За все годы работы программистом я сам использовал то, что будет показано лишь в редких случаях. Однако может случиться так, что в какой-то момент вы столкнетесь с оператором FOR, который очень экзотичен, но работает правильно. Поскольку разговор об этих вопросах займет некоторое время и вы можете столкнуться с чем-то подобным, я должен показать это сейчас. Иначе я могу и забыть об этом позже. Чтобы объяснить это, мы используем очень простой код, а также примем меры предосторожности, чтобы избежать проблем. Когда мы говорим об операторе WHILE, мы используем код, похожий на следующий:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char info = 10;
07. 
08.     do
09.     {
10.         if (((info / 5) * 5) == info) Print("Press ESC to finish counting...");
11.         info = info - 1;
12.         Sleep(200);
13.         Print(__FUNCTION__, " : ", info);
14.     }while (!TerminalInfoInteger(TERMINAL_KEYSTATE_ESCAPE));
15. 
16.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
17. }
18. //+------------------------------------------------------------------+

Код 05

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

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char info = 10;
07. 
08.     for (; ; )
09.     {
10.         if (((info / 5) * 5) == info) Print("Press ESC to finish counting...");
11.         info = info - 1;
12.         Sleep(200);
13.         Print(__FUNCTION__, " : ", info);
14.         if (TerminalInfoInteger(TERMINAL_KEYSTATE_ESCAPE)) break;
15.     }
16. 
17.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
18. }
19. //+------------------------------------------------------------------+

Код 06

Теперь будьте внимательны, потому что я не буду повторять этот момент. Если вы просматривали предыдущие коды в этой статье, то заметили, что все они содержали информацию на выражении 02. Это позволило сделать так, чтобы цикл FOR в какой-то момент завершился. Однако могут быть случаи, когда нужно, чтобы цикл FOR не завершался, по крайней мере, при выполнении некоторого условия, заданного в теле оператора. В этом случае можно использовать пустое выражение 02. Когда это произойдет, цикл НЕ ОСТАНОВИТСЯ, по крайней мере, не из-за условия, указанного в операторе. Такое условие, если оно существует, возникнет внутри процедуры цикла. Как видно из кода 06, условие, останавливающее цикл, определяется в строке 14. Однако, в отличие от того, что многие могут себе представить (что в цикле FOR необходимо объявить какое-то выражение), его можно прекрасно объявить, как показано в строке 8 кода 6. Таким образом, компилятор поймет, что цикл бесконечен, и любой программист также поймет это.

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

Чтобы продемонстрировать, что код 06 действительно работает и не попадает в бесконечный цикл, его результат можно увидеть в анимации ниже:

Анимация 01

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

Заключительные идеи

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

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

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