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

Введение

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

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

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

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

Тем не менее, перед тем, как мы подойдем к первым темам данной статьи, необходимо объяснить термин, который будет повторяться в статьях о операторах. Для этого обратимся к первой теме данной статьи.

Определяем, что такое подпрограмма

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

Рисунок 01

Блок кода из рисунка 01 начинается с открывающеq фигурной скобки и заканчивается закрывающей. Всё, что находится в этом блоке, следует рассматривать как единое целое. Неважно количество строк или то, что находится между открывающей и закрывающей фигурной скобкой. Вы должны думать об этом, как о едином целом. Мы назовем эту вещь ПОДПРОГРАММОЙ.

Теперь будьте внимательны! Подпрограмма может быть и блоком кода, и чем-то похожим на то, что показано ниже.

   {
      ExtAOBuffer[i] = ExtFastBuffer[i] - ExtSlowBuffer[i];

      double sumAO = 0.0;

      for(int j = 0; j < FAST_PERIOD; j++)
         sumAO+=ExtAOBuffer[i - j];

      ExtSMABuffer[i] = sumAO / FAST_PERIOD;
      ExtACBuffer[i] = ExtAOBuffer[i] - ExtSMABuffer[i];

      if ( ExtACBuffer[i] >= ExtACBuffer[i - 1])
         ExtColorBuffer[i] = 0.0; // set color Green
      else
         ExtColorBuffer[i] = 1.0; // set color Red
   }

Это также может быть любое выражение, как указано ниже.

ExtACBuffer[i] = ExtAOBuffer[i] - ExtSMABuffer[i];

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

Оператор IF: «Верховный оператор»

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

Но тогда почему в названии данной темы я сказал, что оператор IF - это «верховный оператор»? И более того, почему я начинаю именно с оператора IF? Разве нельзя начать с другим оператором? Конечно же, мы могли бы начать наш разговор с другим оператором. Однако, если вы действительно понимаете, как работает оператор IF и как использовать то, что объяснено и продемонстрировано в предыдущих статьях, вы сможете сделать практически всё в программировании. Я говорю "практически всё", потому что есть еще одна концепция, которую нужно объяснить, но мы поймем ее лучше, если у нас будет хороший фундамент, построенный на других, более простых операторах, которые мы вскоре рассмотрим. Если вы владеете всеми необходимыми понятиями и правильно их применяете, вы сможете создать буквально любой код, я повторю - любой код. Только при использовании оператора IF, других операторов и переменных, только это и ничего больше. Кажется невозможным, не правда ли? Но я могу вас заверить. И со временем вы убедитесь, что данное утверждение верное.

Однако сейчас мы начнем с понимания очень простой концепции оператора IF. IF в буквальном смысле означает ЕСЛИ. Всякий раз, когда мы встречаем оператор IF, мы должны читать его как ЕСЛИ. Так будет гораздо проще понять, что именно выражает оператор.

При его выполнении, оператор IF проверяет условие. Данное условие ДОЛЖНО быть, и ВСЕГДА должно рассматриваться как истинный или ложный результат (true или false). ВСЕГДА. Неважно, что именно проверяется или анализируется. От того, выполнит ли оператор IF содержащуюся в нем подпрограмму, зависит, будет ли вычисленное условие истинным или ложным. В предыдущих статьях мы уже видели, что условие ложное, если его значение равно нулю, и истинное, если значение ненулевое. Вопреки распространенному мнению, оператору IF не нужны такие операторы, как больше, меньше, равно или аналогичные. Ему нужно только знать, является ли условие истинным или ложным. Ничего больше.

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

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

Код 01

Запустив этот код, мы увидим в терминале MetaTrader 5 нечто похожее на это:

Рисунок 02

Обратите внимание, что здесь мы применяем именно то, что уже объяснялось выше. То есть мы используем шестую строку для определения переменной. Затем, в восьмой строке, мы выводим сообщение, чтобы проанализировать то, что у нас имеется. Прямо в десятой строке у нас есть оператор управления потоком: оператор IF. А теперь внимание. Если info равно true, то выполнится подпрограмма, которая находится в операторе IF. Если info оказывается ложным, то подпрограмма в операторе IF не будет выполнена, что позволит перейти к следующей подпрограмме в коде. Таким образом, мы можем контролировать и направлять поток выполнения нашего кода. Следующая подпрограмма в данном случае находится в строке 13.

Поскольку значение info ненулевое, подпрограмма выполнится внутри оператора IF. Поэтому в результате получается то, что показано на рисунке 02. Здесь есть несколько моментов, касающихся того, как нужно писать данный оператор. Некоторые из этих вопросов являются обязательными, а другие - нет, но в основном синтаксис оператора IF выглядит следующим образом:

Рисунок 03

Здесь прекрасно видно, как выполняется оператор. Это довольно простой способ понять ее синтаксис.

Но а что, если мы хотим выполнять подпрограмму внутри оператора IF не тогда, когда условие истинное, а когда ложное? Можно ли сделать это? Это хороший вопрос, и именно здесь многие начинающие программисты сталкиваются со существенными проблемами, а то и вовсе запутываются. Это происходит так, потому что они НЕ ПОНИМАЮТ концепцию, лежащую в основе оператора. Я снова повторяю: оператор IF выполнит содержащуюся в нем подпрограмму, ЕСЛИ, И ТОЛЬКО ЕСЛИ, УСЛОВИЕ ИСТИННО. Иначе подпрограмма в операторе IF НЕ БУДЕТ ВЫПОЛНЕНА. Как это возможно? Я видел код, в котором значение было ложным, но при этом внутри оператора IF выполнялась подпрограмма. Вы можете сказать, что я не понимаю, о чем говорю.

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

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
07. 
08.     if (true)
09.         Print("True condition...");
10. 
11.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
12. }
13. //+------------------------------------------------------------------+

Код 02

Теперь видно, что проверка в восьмой строке ВСЕГДА будет истинной. Поэтому девятая строка будет выполняться ВСЕГДА, независимо от того, сколько раз выполнится код. Девятая строка будет выполняться ВСЕГДА. Результат можно увидеть ниже:

Рисунок 04

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

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
07. 
08.     if (false)
09.         Print("True condition...");
10. 
11.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
12. }
13. //+------------------------------------------------------------------+

Код 03

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

Рисунок 05

Ух ты, а где же вторая строка, которая появилась на рисунке 04? Куда она делась? Данная строка не появляется в рисунке 05 именно потому что она не была выполнена. И это происходит в связи с тем, что выражение, вычисленное в восьмой строке, является ложным. И оно всегда будет ложным. А если значение ложное, то подпрограмма внутри оператора IF НИКОГДА не будет выполнена. Однако здесь есть небольшая деталь, на которую многие не обращают внимания. Возможно, именно поэтому вы решили, что ложное условие вызывает выполнение подпрограммы внутри оператора IF. А это происходит так, потому что результат выражения каким-то образом инвертируется, то есть то, что было ложным, становится истинным, и наоборот.

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

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

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

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
07. 
08.     if (~false)
09.         Print("True condition...");
10. 
11.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
12. }
13. //+------------------------------------------------------------------+

Код 04

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

Рисунок 06

Обратите внимание, что при первом поверхностном взгляде на код 04, мы можем подумать, что проверенное выражение ложное. Однако обратите внимание на символ, предшествующий зарезервированному слову false. В большинстве случаев мы увидим восклицательный знак (!). Мы также можем использовать множество других ресурсов. Например, зная, что проверка всегда будет верифицировать, равно ли значение нулю, можно написать что-то вроде следующего:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
07. 
08.     if (false | true)
09.         Print("A very crazy condition always true ...");
10. 
11.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
12. }
13. //+------------------------------------------------------------------+

Код 05

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

Рисунок 07

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

Оператор ELSE. Он живет не один.

Одна из ошибок, которую часто совершают новички, возможно, из-за типа материала, на котором они пытаются учиться, - это попытка использовать оператор ELSE сам по себе. Этот оператор, который в некотором смысле можно перевести как ДА НЕТ, всегда сопровождает другой оператор. Оператор, предшествующий ему, зависит от используемого языка программирования. Многие считают, что оператор ELSE всегда связан с оператором IF, но в SQL оператор ELSE может быть связан с оператором CASE. Это может показаться немного странным, но именно так устроен язык. Поэтому не стоит думать, что, раз вы умеете программировать на одном языке, вы автоматически сможете программировать на другом. Многие вещи могут адаптироваться, но каждый язык программирования имеет свои тонкости и детали, которые необходимо понимать.

Если вы поняли оператор IF, то оператор ELSE будет для вас гораздо проще. Это связано с тем, что, будучи связанным с оператором IF, ELSE будет выполняться только в том случае, если выражение, проверенное в операторе IF, окажется ложным. Объяснение оператора ELSE в основном сводится к этому. Больше нечего добавить по отношению к этому.

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

Рисунок 08

Взглянув на рисунок 08, мы заметим, что если есть оператор ELSE, то он каким-то образом связан с оператором IF. Но хотя на первый взгляд это может показаться понятным, на практике это не всегда так. Есть несколько предосторожностей, которые вы должны соблюдать при использовании оператора IF в сочетании с оператором ELSE. Подробнее об этом будет рассказано позже. Но что, если перед этим мы поиграем и изменим коды из предыдущей темы, чтобы включить оператор ELSE? Хорошо, я не буду делать это со всеми кодами, так как это не имеет особого смысла, учитывая простоту данной темы. Давайте возьмем один из кодов и, добавив к нему оператор ELSE, сделаем его таким, как показано ниже:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     int info = 10;
07. 
08.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway... #1 => ", info);
09. 
10.     if (info)
11.         Procedure(info);
12.     else
13.         Print("Variable info is equal to zero...");
14. 
15.     if (info)
16.         Print("True condition...");
17.     else
18.         Print("False condition...");
19.     
20.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway... #2 => ", info);
21. }
22. //+------------------------------------------------------------------+
23. void Procedure(int & arg1)
24. {
25.     Print(__FUNCTION__, " ", __LINE__, " #1 => ", arg1);
26.     arg1 = 0;
27.     Print(__FUNCTION__, " ", __LINE__, " #1 => ", arg1);
28. }
29. //+------------------------------------------------------------------+

Код 06

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

Рисунок 09

Глядя на рисунок 09, можно подумать: "Это слишком много информации для понимания". Но я думаю, что это должно еще больше мотивировать вас сосредоточиться и проявить энтузиазм. Теперь мы разберем каждый пункт по-отдельности. Таким образом, мы начнем лучше понимать, как использовать комбинацию IF ELSE.

Сначала в шестой строке мы создаем переменную, которую будем использовать в коде. В восьмой строке мы выводим то, что будет первой строкой рисунка 09. Если вы поняли оператор IF, то вы точно знаете, что произойдет в строке 10. В данный момент мы можем выполнить или не выполнить подпрограмму под названием Procedure. Чтобы понять происходящее здесь, нужно разобраться с тем, что объяснялось в предыдущих статьях, где мы говорили о переменных. В любом случае, в какой-то момент мы выполним строку 15, и в этот момент выполнится та или иная подпрограмма. Так или иначе, мы выведем новое сообщение на терминал. Наконец, у нас есть строка 20, которая выводит последнее сообщение, видимое на терминале.

Код 06 будет доступен в приложении, чтобы мы могли поэкспериментировать с его небольшими модификациями. Вот несколько предложений по модификации кода. Сначала можно изменить значение переменной в шестой строке, чтобы тест в строке 10 выполнял то одну, то другую подпрограмму. Потом запустим код после внесения данной модификации, чтобы посмотреть, как он себя ведет. Затем начнем вносить изменения в оператор IF с целью получения определенного поведения кода, чтобы он выводил сообщения определенным образом. Далее заменим условия в подпрограмме Procedure так, чтобы оператор IF в строке 15 вел себя по-другому. При каждом изменении смотрим на результат и осознаем, как он был получен. Таким образом, мы сможем хорошо освоить оператор IF. Этот навык будет иметь решающее значение для понимания следующих операторов, которые мы рассмотрим в следующих статьях.

Однако при использовании комбинации IF ELSE возникает небольшая проблема. Чтобы решить данную проблему, давайте начнем с нового вопроса.

Проблема вложенности

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

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

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char c1 = 10,
07.          c2 = 0,
08.          c3 = -6,
09.          c4 = 3;
10. 
11.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
12. 
13.     if (c1)
14.         if (c2)
15.             if (c3)
16.                 if (c4)
17.                     Print("True condition...");
18.     
19.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
20. }
21. //+------------------------------------------------------------------+

Код 07

Вот типичный пример вложенных или каскадных операторов IF. Полагаю, вы уже себя спрашиваете: "А почему нельзя программировать таким образом?" В принципе можно, но более опытные программисты обычно так не программируют, и редко пишут код таким образом. Они создают код, который работает так же, как и код 07, но написан по-другому. Вот один из возможных вариантов его написания:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char c1 = 10,
07.          c2 = 0,
08.          c3 = -6,
09.          c4 = 3;
10. 
11.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
12. 
13.     if ((c1) && (c2) && (c3) && (c4))
14.         Print("True condition...");
15.     
16.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
17. }
18. //+------------------------------------------------------------------+

Код 08

Обратите внимание, что результат кода 07 и кода 08 будет одинаковым. Однако следует обратить внимание на то, что вложенность или каскад IF, которые присутствуют в коде 07, в коде 08 заменены цепочкой логических операторов. В данном случае необходимо использовать операции AND. Любой другой тип операции изменит поведение в коде 08, в результате чего он не будет генерировать тот же результат, что и код 07. Поэтому всякий раз, когда мы не уверены в том, что код правильно выполняет свою работу, мы должны стараться немного изменять способ его написания, чтобы анализируемые выражения были нам понятнее.

Однако проблема вложенности возникает не только с каскадами операторов IF. Она особо часто встречается в комбинации IF и ELSE. Но как возникает такая проблема? Я до сих пор не совсем понимаю это. Итак, чтобы понять это, мы воспользуемся чем-то похожим на код 07, но добавим оператор ELSE. Полученный код показан ниже:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char c1 = 10,
07.          c2 = 0,
08.          c3 = -6,
09.          c4 = 3;
10. 
11.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
12. 
13.     if (c1)
14.         if (c2)
15.             if (c3)
16.                 if (c4)
17.                     Print("True condition...");
18.         else
19.             Print("False condition...");
20.     
21.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
22. }
23. //+------------------------------------------------------------------+

Код 09

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

Проблема здесь заключается именно в ELSE, который присутствует в строке 18. Теперь я спрашиваю вас: с каким IF связан этот ELSE в строке 18?

Из-за так называемого индентации вы можете подумать, что этот ELSE в строке 18 связан с IF, присутствующим в строке 14. На самом деле, некоторые языки программирования интерпретируют код именно таким образом, но это происходит не для всех языков. В реальности в подавляющем большинстве случаев бывает по-другому, и отступы используются не как часть функционального кода, а как способ его упорядочить, чтобы сделать его более читабельным.

По этой причине, а также зная, что в MQL5 отступы НЕ ВЛИЯЮТ на поведение кода, а просто делают его более читабельным, большая ошибка полагать, что ELSE в строке 18 связан с IF в строке 14. В таком виде, как сейчас написан код ELSE в строке 18, он связан с IF в строке 16.

Чтобы решить данную проблему без излишнего усложнения и объяснить, как ее исправить, я покажу два возможных решения. Одно из них предпочитает большинство программистов, а другое используют лишь немногие. Начнем с первого, любимого большинством программистов. Данное решение заключается в разделении кода на блоки, что заставляет компилятор понять, что именно мы хотим сделать. Это также делает программу более читабельной и понятной. Упомянутое решение показано ниже:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char c1 = 10,
07.          c2 = 0,
08.          c3 = -6,
09.          c4 = 3;
10. 
11.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
12. 
13.     if (c1)
14.         if (c2)
15.         {
16.             if (c3)
17.                 if (c4)
18.                     Print("True condition...");
19.         }
20.         else
21.             Print("False condition...");
22.     
23.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
24. }
25. //+------------------------------------------------------------------+

Код 10

На самом деле, это отличное решение. Обратите внимание, что в строке 14 у нас есть IF, с которым мы хотим связать ELSE. Чтобы убедиться, что правильно определена подпрограмма, которая выполнится, если выражение в строке 14 IF будет истинным, мы поместим ее внутрь блока. Поскольку мы вложили целую последовательность IF, то блок, начинающийся в строке 15 и заканчивающийся в строке 19, на самом деле является подпрограммой, которая должна быть выполнена в IF в строке 14. Данный блок можно даже поместить в функцию или процедуру вне блока с названием OnStart.

Очень важно, чтобы вы поняли это. Если выражение IF в строке 14 окажется ложным, программа перейдет непосредственно к оператору ELSE, чтобы выполнить содержащуюся в нем подпрограмму. Обратите внимание, что выполняемая подпрограмма может быть любой, поэтому важно понимать оператор, а не просто запоминать синтаксис или стили программирования.

Обратите внимание на этот факт. Если вы действительно поняли оператор IF и знаете, как сочетать его с оператором ELSE, вы сможете использовать другое решение для кода 09. Однако данный тип решения не получил широкого распространения, поскольку во многих случаях он не делает код по-настоящему понятным. Но поскольку мы работаем с дидактическим материалом и объясняем, как можно поступить, мы можем связывать ELSE, который находится в строке 18 с IF в строке 14. Для этого мы просто связываем другие операторы ELSE с другими операторами IF, как показано ниже:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char c1 = 10,
07.          c2 = 0,
08.          c3 = -6,
09.          c4 = 3;
10. 
11.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
12. 
13.     if (c1)
14.         if (c2)
15.             if (c3)
16.                 if (c4)
17.                     Print("True condition...");
18.                 else;
19.             else;
20.         else
21.             Print("False condition...");
22.     
23.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
24. }
25. //+------------------------------------------------------------------+

Код 11

Обратите внимание, что в коде 11 выявление связи между IF в строке 14 и ELSE, которая теперь является строкой 20, не так просто и понятно. Для его восприятия необходимо тщательно проанализировать код. Однако и код 10, и код 11 приведут к одному и тому же результату при их выполнении. То есть, если IF в строке 14 окажется ложным, то будет выполнена подпрограмма, которая присутствует в соответствующем ELSE.

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

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

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

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