Do básico ao intermediário: Comando IF ELSE

Introdução

O conteúdo exposto aqui, visa e tem como objetivo, pura e simplesmente a didática. De modo algum deve ser encarado como uma aplicação final, onde o objetivo não seja o estudo dos conceitos aqui mostrados.

No artigo anterior Do básico ao intermediário: Passagem por valor ou por referência, foi explicado de maneira bastante prática e objetiva, os conceitos, perigos e cuidados que você deve tomar ao transferir dados entre rotinas diferentes.

Com base justamente naquele conteúdo, assim como o conteúdo visto anteriormente, podemos começar a falar de coisas um pouco mais elaboradas. Isto por que, na programação em propriamente dita, não trabalhamos apenas com expressões matemáticas. Fazer isto, além de ser um tremendo de um desperdício de capacidade computacional e de fatoração que um computador nos oferece. Também limitaria as possibilidades do que poderíamos de fato fazer.

Então o pré-requisito para que você possa entender o que será explicado de agora em diante. É justamente entender o que foi dito e explicado nos artigos anteriores. Se por um acaso você ficar na dúvida de por que algo está ou não acontecendo. Veja os artigos anteriores e procure estudar os artigos com calma. Não seja afoito querendo atropelar os passos que estou mostrando como devem ser dados.

Assim sendo, antes de começarmos realmente o que será os primeiros de diversos tópicos que estarão presentes neste e nos próximos artigos. É preciso explicar um termo que irá aparecer de maneira bastante recorrente nos artigos em que iremos falar sobre comandos. Para isto vamos ao primeiro tópico deste artigo.

Definindo o que seria uma rotina

Toda e qualquer linguagem de programação é definida dentro de determinados termos. Para que possamos ser devidamente compreendidos e ao mesmo tempo, que você venha a entender da maneira correta o que será explicado. Precisamos definir um termo muito importante aqui.

Imagem 01

Um bloco de código como a imagem 01 nos mostra, começa em um abre chave e termina em um fecha chave. Tudo que estiver dentro deste bloco, deve ser pensado como sendo uma coisa só. Não interessa quantas linhas, ou o que existe entre um abre chave e um fecha chave. Você deve pensar nisto como sendo uma única coisa. Esta coisa iremos chamar de ROTINA.

Agora preste atenção. Uma rotina, pode tanto ser um bloco de código, como seria algo parecido com o que é mostrado abaixo.

   {
      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
   }

Como também pode ser uma expressão qualquer, como está mostrada logo a seguir.

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

Até mesmo uma chamada para executar uma função ou um procedimento, entra nesta categoria. Ou seja, tudo isto seria o que iremos chamar de ROTINA. Então quando for referido que uma rotina será executada, você deve entender que poderá usar qualquer uma destas coisas. Desde uma chamada a uma função ou procedimento, até mesmo um bloco inteiro de código. Que poderá conter várias expressões, chamadas de procedimento ou funções, e até mesmo outras rotinas dentro da rotina original. Enfim, expanda sua mente até o infinito e além. Agora sim, tendo definido este termo, podemos começar.

Comando IF: O controle supremo

Antes de começarmos gostaria de deixar um pequeno aviso. Apesar de todos os comandos em programação precisarem serem dados em inglês, você meu caro leitor, e futuro programador. Não é obrigado a usar os comandos em inglês. Existe uma maneira de contornar isto. No entanto, neste momento vamos assumir que você está mesmo começando na programação. Assim, não se preocupe com os termos envolvidos em si. Tente entender o conceito envolvido. Pois saber aplicar o conceito, é muito mais importante do que decorar listas de comandos, com é a sintaxe de cada um.

Mas então, por que eu disse que o comando IF é um comando supremo, no título deste tópico? E mais, por que estou começando justamente pelo comando IF? Será que não poderíamos começar com outro comando? Sim, meu caro leitor, até poderíamos começar falando de outro comando. Porém se você compreender de verdade como o comando IF funciona, E como utilizar o que foi explicado e demonstrado nos artigos anteriores. Conseguirá fazer quase tudo em programação. Digo quase tudo, pois falta explicar um outro conceito. Porém este será melhor compreendido, se você tiver uma base bem construída, em cima de outros comando um pouco mais simples, que iremos ver em breve. Mas se você tiver todos os conceitos necessários e os aplicar de maneira adequada. Literalmente irá conseguir criar qualquer código, e digo qualquer código mesmo. Usando apenas o comando IF, operadores e variáveis. Somente isto e mais nada. Parece impossível não é mesmo? Mas posso afirmar isto. E com o tempo você verá que também é verdade está minha afirmação.

No entanto, neste momento, vamos começar entendendo uma questão bem simples sobre este comando IF. IF quer dizer, e isto literalmente, SE. Sempre que você encontrar um comando IF, leia ele como sendo um SE. Fazendo isto ficará bem mais simples entender o que o comando quer dizer.

Quando executado, um comando IF, irá verificar uma condição. Esta condição OBRIGATORIAMENTE deve ser, e SEMPRE deverá ser pensada como um resultado verdadeiro ou falso. SEMPRE. Não importa o que esteja sendo testado ou analisado. O que fará o comando IF executar ou não a rotina dentro dele, é se a condição de teste é verdadeira ou falsa. Já vimos nos artigos anteriores que uma condição será falsa se o valor for igual a zero, e será verdadeira se o valor for diferente de zero. Ao contrário do que muitos pensam, o comado IF não precisa de operadores como maior, menor, igual ou algo do tipo. Ele apenas precisa saber se a condição venha a ser verdadeira ou falsa. Somente isto e ponto final.

Para tornar isto um pouco mais palatável. Vamos ver um exemplo bem simples deste tipo de coisa, sendo aplicada.

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. //+------------------------------------------------------------------+

Código 01

Ao executar este código você irá ver no terminal do MetaTrader 5, algo do tipo mostrado logo abaixo.

Imagem 02

Observe que aqui, estamos fazendo e aplicando exatamente aquilo que foi explicado a pouco. Ou seja, usamos a linha seis para definir uma variável. Logo depois, na linha oito, imprimimos uma mensagem de forma a analisar o que temos em mãos. No entanto, exatamente na linha dez, temos um comando de controle de fluxo. Este é o comando IF. Agora preste atenção, meu caro leitor. Se info for verdadeiro, a rotina dentro do comando IF será executada. Caso info venha a ser falso, a rotina no comando IF não será executada, passando assim para a próxima rotina presente no código. Com isto podemos controlar e direcionar o fluxo de execução do nosso código. A próxima rotina no caso é a linha 13.

Ok, como o valor de info é diferente de zero, teremos a execução da rotina dentro do comando IF. Assim o resultado é o que vemos na imagem 02. Existem algumas questões aqui, referentes a como você deve escrever este comando. Algumas destas questões são obrigatórias, enquanto outra não. Porém basicamente a sintaxe do comando IF é dada da seguinte maneira:

Imagem 03

Aqui você claramente pode perceber como o comando é executado. Sendo uma maneira bastante simples de entender como é a sintaxe do mesmo.

Muito bem, mas e se não quisermos executar a rotina dentro do comando IF, quando a condição for verdadeira. Mas sim quando ela for falsa. É possível fazer isto? Esta é uma excelente pergunta. E é justamente nela que muitos programadores iniciantes acabam tomando muita pancada, chegando a ficar com o rosto completamente inchado. Isto justamente por que NÃO ENTENDERAM o conceito por trás do comando. Volto a repetir. O comando IF apenas irá executar a rotina dentro dele, SE, E SOMENTE SE, A CONDIÇÃO FOR VERDADEIRA. Fora isto a rotina no comando IF, NÃO SERÁ EXECUTADA. Mas como assim, já vi códigos onde um valor é falso é mesmo assim a rotina dentro do comando IF era executada. Acho que você não sabe do que está falando.

Ok. Não vamos brigar por conta disto. Vamos fazer o seguinte: Iremos criar um simples programa para verificar se isto de fato pode ou não ocorrer. Para isto, vamos forçar uma condição onde a expressão no comando IF sempre será verdadeira. Para isto usamos o código visto logo abaixo.

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. //+------------------------------------------------------------------+

Código 02

Você agora, literalmente pode ver, que o teste feito na linha oito SEMPRE será verdadeiro. Assim, a linha nove, SEMPRE será executa, não importa quantas vezes o código venha a ser executado. A linha nove SEMPRE será executada. Com isto o resultado é visto logo abaixo.

Imagem 04

Agora, você disse que já viu, um comando IF executar a rotina, quando a expressão era falsa. Pois bem, vamos agora fazer com que a expressão seja falsa e ver o que irá acontecer. Isto é mostrado no código logo abaixo. 

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. //+------------------------------------------------------------------+

Código 03

Observe que a única coisa que modifiquei foi a expressão dentro do comando IF da linha oito. Contudo ao executar o código, o resultado é o que podemos ver na imagem abaixo.

Imagem 05

Epá. Mas onde está a outra linha que existia na imagem 04? Onde, diabos ela foi parar? Bem, meu caro leitor, ela não existe nesta imagem 05, justamente por que não foi executada. Isto por que expressão testada na linha oito é falsa. E sempre será falsa. E sendo falsa, a rotina dentro do comando IF JAMAIS será executada. Porém existe um pequeno detalhe aqui, e é onde muitos não prestam atenção. Talvez seja por isto que você tenha acreditado que uma condição falsa faz com que a rotina dentro do comando IF venha a ser executada. Isto se deve ao fato de que o resultado da expressão sendo de alguma forma investido. Ou seja, o que era falso, passou a ser verdadeiro e vice versa.

Preste muita, mas muita atenção mesmo a isto. Pois dependendo da maneira como você escreve o código, você pode ter um valor final verdadeiro, ou falso. Este tipo de coisa, costuma matar muita gente de raiva. Já que as vezes uma expressão aparenta estar correta. Porém devido a alguma questão interna, normalmente relacionada a precedência de operadores. Faz com que a expressão fique errada. Não pelo ponto de vista matemático. Mas sim pelo ponto de vista do comando IF. Esta questão sobre precedência é tão séria. Que merece um artigo apenas para falar sobre isto. Porém, como é algo um tanto quanto complicado de explicar assim logo de começo. Já que envolve o uso de alguns comandos, para que de fato faça algum sentido. Irei adiar um pouco este assunto.

No entanto, você pode estudar isto olhando este tópico da documentação: Regras de precedência

Mas mesmo, sem explicar sobre estas regras, podemos fazer uma simples mudança no código. Assim teremos a rotina dentro do comando IF da linha oito sendo executada. Mesmo quando aparentemente temos uma expressão falsa. Isto é conseguido mudando o código como mostrado abaixo.

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. //+------------------------------------------------------------------+

Código 04

Ao fazermos esta mudança, quase imperceptível. O resultado é o que podemos ver logo abaixo.

Imagem 06

Observe que à primeira vista e olhando o código 04 de maneira descuidada. Acabamos imaginando que a expressão testada é falsa. Porém note o símbolo que antecede a palavra reservada false. Normalmente na grande parte das vezes você irá ver o símbolo de exclamação sendo usado. Podemos usar muitos outros tipos de recurso. Por exemplo, sabendo que o teste sempre será entre o valor ser ou não igual a zero. Você poderia fazer algo do tipo mostrado abaixo.

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. //+------------------------------------------------------------------+

Código 05

Ao executar isto, você irá ver o que é mostrado logo abaixo.

Imagem 07

Enfim, eu poderia ficar aqui mostrando uma serie de possibilidades. Mas nada melhor do que você experimentar as coisas, sabendo o que está de fato ocorrendo. Assim vamos dar como concluído este comando IF e ver o próximo comando. Que de fato não existiria se não fosse o comando IF, e estou falando do comando ELSE. Mas este será explicando no próximo tópico.

Comando ELSE. Este não vive sozinho

Um erro que alguns iniciantes as vezes cometem, e isto talvez seja devido ao tipo de material que eles usam para tentar aprender como programar. É o de tentar usar o comando ELSE de maneira isolada. Este comando que de certa maneira poderia ser traduzido como SENÃO. Sempre está acompanhando de outro comando. O comando que o antecede irá depender da linguagem que você estará utilizando. Muitos acham que o ELSE está sempre ligado ao comando IF. Porém no SQL, o comando ELSE pode estar ligado ao comando CASE. O que pode parecer meio que doideira. Mas é como a linguagem foi pensada. Então não ache que por saber programar em uma linguagem você estará automaticamente habilitado para programar em outras. Muitas coisas podem ser adaptadas. Mas cada linguagem de programação possui suas próprias nuances e detalhes que precisam ser compreendidos.

Se você conseguiu entender o comando IF, entender o comando ELSE será muito mais simples. Isto por que, quando ligado ao comando IF, o mesmo só será executado caso a expressão do comando IF venha a ser falsa. Explicar o comando ELSE, é basicamente isto. Não existe muito mais que podemos falar a respeito do mesmo.

No entanto, podemos dar uma olhada no fluxo de execução. Isto deixará as coisas ainda mais simples de serem entendidas. O fluxo no caso é visto logo abaixo.

Imagem 08

Vendo esta imagem 08, você nota que se existir um comando ELSE ele estará de alguma forma associado a um comando IF. Porém apesar de à primeira vista ser algo bem simples e de fácil compreensão. Na prática, nem sempre é bem assim. Pois existem alguns cuidados que você, meu caro leitor, deverá tomar ao utilizar o comando IF associado a um comando ELSE. Neste artigo ainda vamos falar sobre isto. Mas antes que tão brincar e nos divertir um pouco, modificando os códigos visto no tópico anterior, a fim de que eles tenham o comando ELSE? Bem, não vou fazer isto com todos. Já que, não faz muito sentido devido a simplicidade do que estou mostrando aqui. Assim vamos pegar um dos códigos. E ao adicionar o comando ELSE, um daqueles códigos vistos anteriormente ficará como mostrado logo abaixo.

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. //+------------------------------------------------------------------+

Código 06

Este código 06, que aparentemente é complicado. Na verdade, é bem mais simples e direto, do que muitos podem imaginar ao olhar ele pela primeira vez. E ao executar este código 06, você terá como resultado o que é visto na imagem logo abaixo.

Imagem 09

Você pode estar olhando esta imagem 09, e pensando: É muita informação para entender. Mas, isto é motivo para você ficar ainda mais animado e focar ainda mais. Então vamos entender, cada ponto aqui. Desta maneira você começará a entender melhor como usar a combinação IF ELSE.

Para começar na linha seis, criamos a variável que usaremos no código. Na linha oito, imprimimos o que será a primeira linha na imagem 09. Se você entendeu o tópico sobre o comando IF, sabe bem o que irá ocorrer na linha 10. Neste momento poderemos ou não executar a rotina chamada Procedure. Aqui para entender o que está acontecendo é necessário você entender o que foi explicado nos artigos anteriores. Onde falei sobre variáveis. De qualquer maneira, em algum momento iremos executar a linha 15. E neste ponto poderemos ter uma ou outra rotina sendo executada. De uma forma ou de outra, iremos imprimir uma nova mensagem no terminal. E para finalizar temos a linha 20, que irá imprimir a última mensagem vista no terminal.

Este código 06 estará no anexo para que você possa experimentar pequenas mudanças no mesmo. Aqui vai algumas dicas para modificar o código. Primeiro mude o valor da variável que está na linha seis. Isto de forma que o teste na linha 10 venha a executar uma ou outra rotina. Execute o código depois de ter feito esta modificação para entender como ele se comportou. Depois comece fazendo mudanças nos comandos IF. Isto a fim de ter um determinado comportamento do código. De forma que ele imprima as mensagens de uma determinada maneira. Mude as condições dentro da rotina Procedure, afim de que o comando IF da linha 15 tenha um comportamento diferente. A cada mudança que você fizer, veja o resultado e entenda por que aquele resultado está sendo gerado. Assim você conseguirá ter um bom domínio sobre o comando IF. E este domínio será importante para entender os próximos comandos que serão vistos nos próximos artigos.

Mas existe um pequeno problema quando usamos este conjunto IF ELSE. Para abordar este problema, vamos iniciar um novo tópico.

O problema do aninhamento

Quando se utiliza de forma um pouco mais intensa a combinação IF ELSE, costuma surgir um pequeno problema. Este problema é conhecido como um problema de aninhamento. Onde temos uma cascata de IF e ELSE um dentro do outro. Apesar deste problema surgir quando existe o casamento entre IF e ELSE, ele não surge quando temos apenas e somente comandos IF aninhados. Porém aninhar, ou colocar comandos IF em um formado de cascata não é algo que um programador mais experiente irá fazer. Isto por que não faz sentido tal construção.

Para que você meu caro leitor, consiga compreender do que estou falando, ao usar estes termos: Aninhamento e cascata. Vejamos um exemplo onde isto aparece.

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. //+------------------------------------------------------------------+

Código 07

Aqui está um típico exemplo de aninhamento ou cascata de comandos IF. Imagino que você já deva estar se perguntando: Cara, que mal existe em se programar assim? Nenhum meu caro leitor. Porém, programadores mais experientes não utilizam esta forma de programar. Raramente eles fazem um código desta maneira. Normalmente você os verá fazendo um código que irá funcionar da mesma forma que este código 07. Só que escrito de uma outra maneira. Uma possível forma de escrever as coisas, seria a que é mostrada logo abaixo.

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. //+------------------------------------------------------------------+

Código 08

Observe que o resultado tanto do código 07 quanto do código 08 será o mesmo. No entanto, você precisa prestar atenção ao fato de que o aninhamento ou cascata de IF usados no código 07. Aqui no código 08 foi substituído por uma cadeia de operadores lógicos. No caso, é necessário utilizar operações AND. Qualquer outro tipo de operação que for usada. Irá fazer com que o código 08, não tenha o mesmo resultado que o código 07. Assim, sempre que você não estiver seguro, se o código está ou não fazendo o seu trabalho corretamente. Tente mudar um pouco a forma de escrever o mesmo. De maneira que as expressões a serem analisadas estejam claras para você.

Mas o problema, de aninhamento, não ocorre em cascata de comandos IF. Ele irá ocorrer no casamento entre IF e ELSE. Mas como este tipo de problema ocorre? Ainda não consegui entender. Bem, meu caro leitor, para entender vamos usar algo parecido com o código 07. Mas vamos colocar um comando ELSE nele. Assim o código a ser estudado pode ser visto logo abaixo.

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. //+------------------------------------------------------------------+

Código 09

Veja que o código se parece muito com o código 07. Porém aqui neste código 09 temos um problema e dos grandes. Se você, não tem ideia do tamanho do problema que temos aqui, é por que de fato, você precisa destes artigos para lhe ajudar a entender melhor como criar seus programas.

O problema aqui, meu caro leitor é justamente este ELSE, presente na linha 18. Agora lhe pergunto: A qual IF este ELSE, presente na linha 18, está vinculado?

Por conta de uma coisa chamada de indentação, você poderia dizer que este ELSE da linha 18 estaria vinculado ao IF presente na linha 14. De fato, algumas linguagens de programação irão compreender o código desta maneira. Porém, isto não corre em todas linguagens. Na verdade, na grande maioria dos casos isto não ocorre, já que a indentação seria utilizada não como parte do código, mas sim como uma forma de organizar o próprio código, o tornando mais legível.

Devido a isto, e sabendo que aqui no MQL5, a indentação NÃO INFLUENCIA no código, mas sim o torna mais legível. Entender que o ELSE na linha 18 está vinculado ao IF da linha 14 é um grande erro e equívoco. Da forma como o código está escrito. O ELSE da linha 18 está vinculado ao IF da linha 16.

Agora existe, sem gerar muita complicação e a fim de explicar como corrigir este problema. Vou mostrar duas possíveis soluções. Sendo uma, a preferida por uma enorme maioria de programadores. Enquanto a outra, poucos programadores de fato fazem uso da mesma. Vamos começar com a primeira, que é a favorita de grande parte da comunidade de programadores. Esta faz uso de uma separação em blocos dos códigos. Isto força o compilador a entender exatamente o que queremos fazer. Além é claro, torna o programa muito mais legível e fácil de compreender. Tal solução é vista logo abaixo.

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. //+------------------------------------------------------------------+

Código 10

Está de fato é uma excelente solução. Veja que na linha 14 temos o IF no qual queremos que o ELSE esteja vinculado. Assim precisamos garantir que a rotina será executada, caso a expressão no IF da linha 14 seja verdadeira, esteja de fato dentro de um bloco. Já que estamos aninhando toda uma sequência de IF. Desta maneira, o bloco que se inicia na linha 15 e vai até a linha 19, é de fato a rotina a ser executada dentro do IF da linha 14. Podendo inclusive ser colocada dentro de uma função ou procedimento fora deste bloco chamado OnStart.

É muito importante que você entenda isto meu caro leitor. Pois caso a expressão do IF da linha 14 seja falsa, iremos diretamente para o comando ELSE, a fim de executar a rotina presente dentro dele. Perceba que a rotina, a ser executada pode ser qualquer coisa. Por isto é importante compreender o comando e não ficar apegado em decorar sintaxe ou estilo de programação.

Agora preste atenção a este fato. Se você realmente entendeu o comando IF e sabe como casar ele com o comando ELSE. Pode fazer uso de uma outra solução. Para o código 09. Porém este tipo de solução que iremos ver a seguir, não é muito adotada. Isto por que, em muitos casos, ela não deixa o código realmente claro. No entanto, como aqui estamos tratando de um material didático, e voltado a explicar como podemos fazer as coisas. Podemos fazer com que o ELSE presente na linha 18, seja vinculado ao IF da linha 14. Bastando para isto vincular outros comandos ELSE aos demais IF, como mostrado abaixo.

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. //+------------------------------------------------------------------+

Código 11

Note que aqui no código 11, perceber o vínculo entre o IF da linha 14 e o ELSE do que agora é a linha 20. Não é tão simples e direto. Você precisa, analisar o código para conseguir perceber isto. Porém tanto o código 10, quanto o código 11 terão o mesmo resultado quando executados. Ou seja, caso o IF da linha 14 venha a ser falso teremos a execução da rotina presente no ELSE correspondente.

Considerações finais

Neste artigo, começamos a trabalhar com comandos de controle de fluxo. Sei que este tipo de material, pode ser bastante confuso no começo. Mas se você, meu caro leitor, se dedicar, a fim de estudar com calma. E sempre praticar o que está sendo mostrado e visto aqui, a fim de criar novas soluções para problemas que você pretende resolver. Com o tempo você irá atingir um nível de excelência, alcançado por poucos.

Mas para isto, é preciso sempre estar estudando e procurando encontrar uma solução melhor para um mesmo problema. Não é só por que o problema foi resolvido, que pode não existir uma solução melhor. Sempre há uma solução melhor. Depende de você estudar para conseguir enxergar além do que é obvio.

Um último ponto, é que no anexo, você não terá todos os códigos vistos aqui. Apenas parte deles estará disponível para você. Porém, isto não impede de você, de estudando o artigo. Fazer as mudanças a fim de que no final tenha todos os códigos visto aqui. Além de ser uma boa medida para aprendizado. Isto irá lhe ajudar a encontrar seu estilo. Pois o código pode ser o mesmo. Porém a forma como ele está escrito, pode variar de programador para programador. Dependendo é claro do estilo que cada um adotou como sendo o seu. Então meu caro leitor, chegou a hora de começar a criar seu estilo de programação. Procurado encontrar a forma que torna o seu código, agradável para outros programadores, assim como também lhe ajudará a criar e modificar rapidamente suas próprias soluções.