Do básico ao intermediário: Comando SWITCH

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: Diretiva Include, falamos sobre o básico de como utilizar a diretiva de compilação #include. Mas aquilo foi apenas para que fosse dado um tempo, para que você pudesse assimilar adequadamente e procurar estudar como trabalhar com os comandos de controle de fluxo de execução. Isto por que, de fato é muito necessário que você os estude e assimile muito bem como trabalhar com aqueles comandos. Se bem que ainda não terminamos. Falta falar de mais dois comandos encontrados no MQL5. Como estes dois comandos são relativamente um pouco mais elaborados. Isto em termos de coisas que você necessita prestar atenção quando for utiliza-los. Irei tentar abordar ambos com muito mais calma.

Isto porque, qualquer mínimo deslize que você, como programador, vier a cometer, no uso destes dois últimos comandos. Fará com toda a certeza, com que você perca muito, mais muito tempo mesmo, tentando entender onde está a falha no seu código.

Se você achou os comandos anteriores tensos e complicados. Se prepare, pois estes dois últimos, requerem de fato bastante atenção. Mas no final destes artigos, você conseguirá pelo menos entender como cada um funciona. Então a primeira coisa que se deverá ter para conseguir acompanhar o que será explicado aqui é saber trabalhar com variáveis e constante. Assim como também saber trabalhar com o comando IF. Sabendo fazer isto, você estará apto a prosseguir e entender o conteúdo que será mostrado neste artigo.

Como de praxe, vamos iniciar um novo tópico. Assim, poderemos começar a falar do penúltimo comando a ser explicado.

Comando SWITCH

Este comando, que literalmente quer dizer, interruptor. Serve como um possível substituído ao comando IF. Porém, existe um pequeno detalhe aqui. Isto para que você de fato possa utilizar o comando SWITCH no lugar do comando IF.

Para entender quando e como isto irá ocorrer. Preciso que você, meu caro e estimado leitor, venha a entender uma outra coisa. Existem situações, não raras, em programação, onde testamos uma mesma variável, a fim de encontrar um valor MUITO ESPECIFICO. Esta frase muito específica, é o ponto chave aqui. Isto por que, o valor não pode ser maior, menor ou parecido. Ele tem que ser EXATAMENTE aquele que estamos procurando. Nem mais, nem menos. EXATAMENTE.

Quando este tipo de situação acontece, podemos abrir mão de usar diversos comandos IF e usar apenas um único comando SWITCH. Porém, toda via e, entretanto, você precisa entender que a largura de bits e o formato que será utilizado no comando SWITCH, afeta profundamente a possibilidade de usar ou não ele.

Resumindo: Você somente poderá usar SWITCH em substituição a vários comandos IF, se e somente se, a variável que será testada é a mesma em diversos IF diferentes. Você somente poderá testar se a variável é ou não um determinado valor. Não sendo possível testar se for maior ou menor que um dado valor. E a largura de bits, influência no resultado testado. Isto resumi de maneira bem simples o que é o comando SWITCH.

Olhando desta forma parece ser algo muito complicado. Ou no mínimo pouco utilizado na prática. Porém, é exatamente o contrário disto, que você pode ter pensado. O comando SWITCH é bastante utilizado em diversas situações diferentes. Mesmo que você possa acha-lo muito limitante e de difícil utilização.

Mas o que realmente tornar o comando SWITCH um tanto quanto complicado e confuso para muitos programadores iniciantes, ou programadores casuais, que fazem isto por hobby. É justamente a maneira como ele trabalha em diferentes linguagens e diferentes cenários. Mas aqui iremos focar, em como trabalhar com o comando SWITCH dentro do MQL5. Como neste caso ele se parece bastante com a forma de trabalhar do C/C++. Você pode até procurar documentação do C/C++, como forma de complementar e se aprofundar em certas características deste comando SWITCH. Isto por que, o que será abordado aqui é o básico da coisa toda. Voltado apenas em introduzir como o comando funciona e alguns cuidados a serem tomados. Mas existe muita coisa sobre ele, se você procurar este comando dentro do C/C++.

Ok, acredito que tenho passado uma ideia do que vem pela frente, e de onde você pode procurar se aprofundar um pouco mais. Então chegou a hora de mergulharmos de cabeça neste comando e começar a explorar as possibilidades de uso do mesmo. para isto, vamos começar com um exemplo bastante simples. Sem ainda usar o comando propriamente dito. Então vamos dar uma olhada no código logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     uchar counter = 5;
07. 
08.     if (counter == 5) Print("The counter value is five."); else
09.     if (counter == 3) Print("The counter value is three."); else
10.     if (counter == 1) Print("The counter value is one."); else
11.         Print("The counter value is unknown.");
12. }
13. //+------------------------------------------------------------------+

Código 01

Sei que muitos vão olhar e dizer: Cara que código mais bobo. Sim, eu sei, mas precisamos realmente começar com algo bem simples mesmo. Caso contrário você irá ficar maluco tentando entender o que estará ocorrendo depois.

Bem, só olhando este código, você claramente consegue entender o que será mostrado no terminal do MetaTrader 5. Sendo assim, imagino ser completamente desnecessário mostrar qual será a mensagem impressa lá. Agora, caso você não consiga saber, apenas olhando este código, meu caro leitor. Sugiro fortemente, se sem nenhuma dor no coração, que você, meu estimado leitor, pare imediatamente, rebobine a fita e comece vendo os artigos do início. Começando com o primeiro artigo que é: Do básico ao intermediário: Variáveis (I). Não ache que você irá aprender a programar, queimando etapas. Pois não vai. Comece entendendo os primeiros conceitos e comandos antes de tentar novos voos, em terreno desconhecido.

Muito bem, então vamos continuar. Aqui você claramente percebe que temos exatamente o que foi definido no começo deste tópico. Ou seja, temos uma única variável, tendo seu valor analisado em diversos comandos IF diferentes. E em cada um deles estamos procurando analisar um único e somente um único valor. Não estamos procurando um valor que seja, maior ou menor. Mas sim um valor exato. Este é o ponto chave. Ou seja, uma vez que temos algo parecido com o que é visto no código 01, podemos utilizar um comando mais agradável. E este comando é o comando SWITCH.

Tendo agora isto bem claro e bastante definido, podemos ver um outro código que irá produzir exatamente o mesmo tipo de resultado, quando for executado. Este código é mostrado logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     uchar counter = 5;
07. 
08.     switch (counter)
09.     {
10.         case 5:
11.             Print("The counter value is five.");
12.             break;
13.         case 3:
14.             Print("The counter value is three.");
15.             break;
16.         case 1:
17.             Print("The counter value is one.");
18.             break;
19.         default:
20.             Print("The counter value is unknown.");
21.     }
22. }
23. //+------------------------------------------------------------------+

Código 02

E aí está meu caro leitor, este código 02 é similar ao código 01. E gera o mesmo tipo de resposta. Sem nenhuma diferença entre elas. Mas você pode estar pensando: Cara, mais isto daqui é muito mais complicado. Prefiro utilizar o código 01 do que este código 02. Bem, não posso negar que olhando de maneira bem superficial. De fato, este código 02, aparenta ser bem mais complicado. Mas então por que alguém iria preferir usar este código 02 e não o código 01, durante a implementação de seus códigos? Na verdade, meu caro leitor, isto não é assim tão simples de ser explicado, utilizando o comando SWITCH na sua forma mais básica e simples. Porém posso garantir a você que existem diversas situações onde o comando SWITCH leva muita vantagem sobre o comando IF. Isto devido a uma capacidade que o comando SWITCH tem, e o comando IF não tão. Que é a de penetrar em valores diferentes dos que estamos testando.

Mas este tipo de coisa é um tópico um pouco mais avançado no uso do comando SWITCH. Apenas mencionei ele neste momento, para que você não ignore este comando, apenas por achar ele confuso e complicado. Ele na verdade é muito mais útil do que aparenta ser.

Beleza. Agora vamos olhar com um pouco mais de calma este código 02. Aqui você pode observar alguns detalhes curiosos sendo utilizados. Primeiro: O que este comando BREAK está fazendo aqui? Ele não é um comando usado dentro de laços? Isto mesmo meu caro leitor. O comando BREAK visto aqui é de fato usado em laços. Porém, toda via e, entretanto, ele também é usado em alguns momentos aqui no comando SWITCH. Isto para que possamos controlar como o comando irá trabalhar. Ou melhor dizendo. Quando usamos este comando BREAK, estamos falando para o compilador que naquele ponto, dentro da rotina SWITCH, queremos que ela pare de ser executada. Assim o compilador sabe exatamente o que fazer. De certa maneira, parece um pouco com o que ocorre dentro de um laço. A diferença aqui é que existe uma separação das coisas que serão feitas. Não se preocupe, nos já vamos chegar neste ponto. Mas antes quero falar sobre uma outra coisa que você também pode observar aqui, que são estas palavras reservadas CASE. Se você observar com atenção os códigos 01 e 02, irá notar uma certa similaridade sendo aplicada aqui.

O comando SWITCH aparece como sendo um IF, agora entramos em um bloco e a palavra CASE seria o equivalente ao sinal de igualdade que é mostrado dentro da expressão de cada um dos IF vistos no código 01. E depois disto temos um valor, que é exatamente o mesmo valor que você pode observar em cada expressão do comando IF. Interessante isto não é mesmo? E isto não é proposital meu caro leitor. É assim mesmo que o comando SWITCH trabalha e deve ser pensado, quando você o for utilizar na prática. Por isto que olhando-o de maneira superficial, o comando SWITCH parece muito mais complicado do que realmente é. Quando você começa a entender ele, o mesmo passa a ser simples e bastante interessante. E você logo começa a pensar em novas possibilidades.

No entanto, no código 01 temos a linha 11, que será executada, quando nenhum valor corresponder ao que era esperado. A mesma coisa acontece aqui no SWITCH. Só que para conseguir fazer isto, usamos uma outra palavra reservada que é: DEFAULT. Esta palavra dentro de uma rotina, ou bloco SWITCH, diz ao compilador, que caso não seja encontrado nenhum valor que corresponda ao valor testado na expressão SWITCH, uma rotina a parte deverá ser executada. Normalmente, este que iremos chamar de um sub comando, DEFAULT, é colocado no final do que seria um bloco dentro do SWITCH. Isto para manter uma certa lógica construtiva do comando SWITCH. Mas nada impede de você o colocar em qualquer local dentro do bloco SWITCH. Apenas fica um tanto quanto estranho e estravagante fazer este tipo de coisa.

Muito legal isto não é mesmo? Agora tem mais um detalhe, que merece ser destacado. Isto pode deixar ainda mais claro a utilidade do comando SWITCH. Tal detalhe se refere ao seguinte fato: Um comando IF somente irá executar a rotina que pertence a ele. Se e somente se o valor da expressão for verdadeiro. Não importar o valor, para que a rotina seja executada, o valor precisa ser verdadeiro. No caso do comando SWITCH a coisa é um pouco diferente. Neste caso, o valor da expressão irá ser testado de maneira numérica. Ou seja, o que nos interessa de fato é se o valor é igual ou não ao que estamos testando. E o bloco CASE somente será executado se e somente se o valor for igual ao que está na expressão do comando SWITCH. Porém o bloco CASE somente termina em um comando BREAK ou no final do comando SWITCH. Então tome cuidado com isto.

Por enquanto, sempre coloque um comando BREAK antes de iniciar um novo CASE. Isto para evitar que você venha a ficar com um código todo confuso. No futuro iremos explorar outras possibilidades, onde não usaremos o comando BREAK em certas situações. Mas até lá, sempre coloque um comando BREAK antes de um novo comando CASE.

Ok, de qualquer forma, vamos ver como seria o fluxo de execução do comando SWITCH. Este pode ser observado logo na imagem abaixo.

Imagem 01

Aqui temos algo um pouco diferente do que foi visto nos demais fluxos de execução. Isto por que, de fato esta imagem 01 demonstra como você deve entender o comando switch. Então se você quer realmente compreender, mesmo antes de que eu venha a explicar, como o comando switch funciona em um modo mais avançado um pouco. É preciso entender de maneira adequada esta imagem 01. Isto por que, se você de fato compreender esta imagem, irá conseguir explorar o comando switch sem nenhuma dificuldade. Mesmo em um nível mais elevado do que este que estamos demonstrando neste momento.

Então vamos as explicações. Você pode notar que tudo começa como em qualquer outro comando. Ou seja, quando usamos a palavra reservada para identificar o comando a ser utilizado. Deste momento em diante, até o final quando atingimos a bolinha de saída. Tudo que se passa aqui, pertence a rotina dentro do comando switch. Não sendo de forma alguma visível para nenhum outro comando externo. Entender isto é crucial para compreender algo que iremos explorar em breve, ainda neste artigo.

Muito bem, entendido esta questão. A próxima coisa que temos é a expressão. Esta expressão, deverá ser pensada em termos numéricos. E não em termos lógicos. E o que isto significa na prática? Bem, na prática, isto significa que usar coisas como maior, ou menor dentro da expressão, não terá exatamente o efeito que você poderia imaginar obter. Então não temos algo como no caso do comando IF, onde o que nos interessa é se a expressão é verdadeira ou falsa. Aqui a expressão deverá SEMPRE SER PENSADA COMO SENDO UM NÚMERO. O número a ser utilizado como sendo a resposta irá depender do próximo passo.

Este próximo passo são os comandos CASE. Aqui é onde a expressão será testada de maneira lógica. Ou seja, ela será analisada como verdadeira ou falsa. Mas espere um pouco aí. Agora fiquei confuso. Você acabou de dizer que a expressão NÃO será analisada como sendo verdadeira ou falsa. Mas sim usando valore numéricos. E agora você diz que ela irá ser analisada como sendo verdadeira ou falsa? Cara, você precisa se decidir, assim ninguém vai conseguir te entender.

De fato, meu caro leitor, isto parece ser um tanto quanto confuso. Mas não tem como explicar de outra forma. Você pode observar que a expressão é jogada contra vários comandos CASE. E não existe de fato uma ordem aqui. Apenas o fato de que na linha entre a expressão e o comando CASE o que existe são valores numéricos. Porém no momento em que o comando CASE for executado, ele irá analisar a coisa como valores lógicos. Ou seja, como sendo verdadeiro ou falso. Justamente por conta disto, que junto ao comando CASE, estou colocando uma outra informação que é VALUE. Isto sim irá validar o valor da expressão junto ao comando CASE, permitindo assim que ROUTINE venha ou não a ser executada. Como para permitir ou não a execução de algo, precisamos comparar as coisas de maneira lógica. Fica um pouco confuso explicar cada detalhe deste comando. Já que muitos poderiam imaginar que o teste estaria sendo feito lá na expressão. Quando na verdade ele é feito de fato, durante o comando CASE.

Eu não disse que este comando switch era um tanto quanto confuso, se você não estiver compreendendo o que foi explicado nos artigos anteriores? E olha que aqui, estamos trabalhando com ele no seu nível mais simples de atividade.

De qualquer forma, quando CASE verificar que EXPRESSIOIN é igual a VALUE iremos executar ROUTINE. Ponto nova linha. Agora vem a parte que será explicada em um outro momento, que é justamente esta linha vem vermelho na imagem 01. Esta linha e justamente nela é onde a coisa de fato complica e complica bastante. Mas não iremos falar sobre isto agora. Vamos ignorar esta linha vermelha por hora. E a menos que você queira se adiantar, estudando o que acontece quando o fluxo passa por esta linha vermelha. Não mexa com ela ainda. Faça exatamente o que irei falar agora. No final do que seria o código presente em ROUTINE, você deverá colocar um comando BREAK. Ao fazer isto chegaremos finalmente ao ponto de saída do comando switch. Ufá, este comando é divertido, mas pode causar um baita nó no cérebro de muita gente, em certas situações. Já que existem formas de modelar o código que deixa tudo extremamente complicado de analisar. Sem que você realmente saiba como cada comando de controle de fluxo funciona.

Beleza, tudo muito lindo, tudo muito belo. Mas estou com uma pulga atras da orelha me incomodando. Nos artigos anteriores, vimos que o comando BREAK serve para nos dar um meio de sair de um laço. Isto sem passar pelo teste da expressão do laço. Aquilo consegui entender. Porém vendo este comando switch, também usando o comando BREAK, fiquei um pouco quanto confuso, com relação a uma coisa. Será que se estivermos dentro de um laço e usarmos o comando BREAK dentro de um switch, como você disse para usarmos. Será que isto não fará o laço ser finalizado antes da hora? Esta sim é uma excelente questão, meu caro leitor. Isto sim é uma pergunta de quem de fato está conseguindo acompanhar e compreender cada um dos artigos que publiquei até agora sobre este tema. Vamos fazer o seguinte: Como já sabemos como criar um laço, e controlar internamente como ela irá funcionar. Isto utilizando os comandos BREAK, RETURN e CONTINUE. Vamos fazer algo que torne tudo isto devidamente explicado e adequadamente compreendido.

Para isto, vamos utilizar um código um pouco mais elaborado do que o visto no começo deste artigo, e também visto nos demais artigos. Este é mostrado logo abaixo. Lembrando que o objetivo aqui é a didática, e não o de criar algo em especial.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     Print(__FUNCTION__, " ", __LINE__, " Counting...");
07.     Print(__FUNCTION__, " ", __LINE__, " Pit Stop :: ", Tic_Tac());
08.     switch (Tic_Tac())
09.     {
10.         case true:
11.             Print(__FUNCTION__, " ", __LINE__, " Return TRUE");
12.             break;
13.         case false:
14.             Print(__FUNCTION__, " ", __LINE__, " Return FALSE");
15.             break;
16.     }
17. }
18. //+------------------------------------------------------------------+
19. bool Tic_Tac(void)
20. {
21.     static uchar counter = 10;
22. 
23.     while (true)
24.     {
25.         switch (counter)
26.         {
27.             case 8:
28.                 counter = counter - 1;
29.                 return false;
30.             case 6:
31.                 Print("Press TAB to continue or ESC to abort the count.");
32.                 counter = counter - 1;
33.                 break;
34.             case 5:
35.                 if (TerminalInfoInteger(TERMINAL_KEYSTATE_TAB))
36.                 {
37.                     Print("Accelerating count.");
38.                     counter = 2;
39.                 } else if (TerminalInfoInteger(TERMINAL_KEYSTATE_ESCAPE))
40.                 {
41.                     Print("General panic...");
42.                     return false;
43.                 }
44.                 continue;
45.             case 0:
46.                 return true;
47.             default:
48.                 counter = counter - 1;
49.         }
50.         Print(__FUNCTION__, " ", __LINE__, " :: ", counter);
51.         Sleep(300);
52.     }
53.     Print(__FUNCTION__, " ", __LINE__, "This line will never be executed.");
54. }
55. //+------------------------------------------------------------------+

Código 03

Este código 03 contém alguns elementos de construção e implementação de código bem interessantes. Isto por que, aqui estamos usando praticamente quase tudo que foi visto até este momento. No entanto antes de falarmos sobre este código 03, vamos entender o que acontece quando executamos ele no terminal do MetaTrader 5. Na verdade, existe duas possibilidades de resultado aqui. Sendo cada uma mostrada em uma das animações abaixo.

Animação 01

Nesta animação 01, você pode observar o que acontece quando pressionamos a tecla ESC. Agora quando pressionamos a tecla TAB, iremos ver algo um pouco diferente. E isto está sendo mostrado na animação logo abaixo.

Animação 02

Observe que temos uma diferença bem sutil entre uma e outra animação. Porém a parte que realmente nos interessa, é como estas informações foram parar no terminal e como os comandos de controle de fluxo controlaram quando cada informação seria apresentada.

Bem, meu caro leitor, aqui não vou detalhar certas partes. Isto por que, quero que você procure estudar os artigos anteriores. Isto a fim de realmente conseguir aprender como cada comando de controle de fluxo funciona. No entanto, ainda assim, irei dar uma explicação sobre como as coisas ocorram aqui no código 03.

Vamos começar pelo ponto de entrada do código, ou seja, OnStart. A linha seis indica onde estamos na execução. Ela é impressa assim que é executada. Mas no caso da linha sete as coisas não irão ocorrer imediatamente. Isto por que, nesta mesma linha temos uma chamada para a função Tic_Tac. Por conta disto a execução total da linha sete será adiada até que a função Tic_Tac finalize suas tarefas.

Ok, uma vez dentro da função Tic_Tac na linha 19. Entraremos em um laço infinito na linha 23. Mas não precisa ficar desesperado meu caro leitor. Este laço é infinito, mas temos meios de sair dele em alguns pontos. Agora preste atenção para entender o que estará ocorrendo aqui. Note que na linha 25 entramos com um comando de controle de fluxo, que é o switch. E a cada valor de contagem, que nos interessa, iremos fazer algum tipo de ação. Lembre-se de que a variável de contagem é do tipo estática. Isto é importante. Então quando a contagem atingir o valor oito, iremos retornar ao chamador. E retornaremos com um valor falso. Neste momento a linha sete irá ser totalmente executada. Daí a mensagem sendo vista na tela do terminal. Uma vez feito isto, iremos na linha oito, chamar novamente a função Tic_Tac. Mas desta vez iremos usar o retorno da função como sendo uma expressão de um comando switch. E novamente a execução do comando irá ficar aguardando que a função Tic_Tac, cumpra suas tarefas. Então voltamos novamente a execução do código presente na linha 19.

Mas espere um pouco. Nós não havíamos saído na linha 29? Este retorno não fará o código repetir tudo do começo, nos fazendo finalizar o laço da linha 23, exatamente na linha 29 novamente? Na verdade, isto até ocorreria de fato, meu caro leitor. Porém justamente por conta da linha 28 ter sido executada antes de retornarmos ao chamador. Agora não estamos apontando para o valor oito e sim para o valor sete. Como não existe nenhum tipo de atividade no comando switch da linha 25, que faça a expressão, ser executada no valor sete, iremos neste caso executar a linha 47. Como esta linha 47, tem como rotina apenas a linha 48, que reduz o contador em uma unidade. Agora iremos estar apontando para o valor seis.

De qualquer modo, iremos executar depois de efetivamente cumprida a parte do comando switch. As linhas 50 e 51. Por isto alguns valores não são mostrados no terminal, como é o caso deste valor sete. Mas uma vez que tenhamos impresso o valor seis, iremos voltar ao início do laço. E mais uma vez executar o comando switch. Só que agora a expressão tem como valor o valor seis. E este tem um CASE associado a ele. Agora preste atenção. Quando a linha 31 é executada, iremos imprimir uma nova mensagem no terminal. Logo depois na linha 32 iriemos fazer o contador apontar para o valor cinco. Mas o que acontece na linha 33, onde temos um comando BREAK sendo executado? Aqui é onde muito iniciante fica bastante confuso. Isto por que, este comando BREAK que foi visto em um artigo anterior, faz com que o laço, onde ele é declarado, venha a ser encerrado. Isto é fato, e foi demonstrado no artigo onde este comando foi explicado. Porém, toda via e, entretanto, NÃO É O QUE IRÁ OCORRER AQUI. Isto porque neste caso especifico o comando switch tem prioridade sobre qualquer laço onde ele estiver sendo utilizado. Ou seja, o comando BREAK, neste caso irá está se referindo ao comando switch e NÃO ao comando de laço. Seja ele, WHILE, DO WHILE ou FOR.

Sei que isto é um pouco confuso. Mas para provar que isto de fato ocorre. Coloquei na linha 53, uma mensagem que JAMAIS será impressa, neste código 03. Mesmo existindo este comando break na linha 33. Sendo o único break presente em todo o código 03.

Ok, creio que isto deva ter ficado claro. Mas de qualquer forma, este código estará no anexo. Então estude o mesmo com bastante calma até que você consiga entender esta pequena peculiaridade para o uso do comando break.

Assim que o comando BREAK é executado na linha 33, iremos diretamente para a linha 50. Lembre-se de que o contador foi subtraído na linha 32. Por isto a mensagem mostrada, diz que estamos com o valor cinco na variável de contagem.

Novamente o laço será executado e mais uma vez o comando switch. Só que agora a expressão aponta para o valor cinco. Como temos um CASE associado a este valor, iremos executar ele. E é neste ponto que algo interessante acontece. Novamente preste atenção para compreender o que estará ocorrendo aqui meu caro leitor. Aqui iremos ficar aguardando que o usuário pressione uma das teclas mencionadas na mensagem postada quando o contador tinha o valor seis. Mas, e este é o ponto que você precisa entender aqui. Caso o usuário não pressione nenhuma tecla, iremos executar o comando CONTINUE. Isto na linha 44. Agora vem a questão. Como este comando continue, sempre estará associado a um laço. Aqui iremos voltar imediatamente para a linha 23. Sendo assim, as linhas 50 e 51, param de ser executadas. Isto enquanto o valor da expressão for igual a cinco. Quando o usuário pressionar uma dadas teclas teremos o fluxo sendo modificado mais uma vez. Em um caso iremos executar a linha 38, que fará o contador mudar para o valor dois. E em outro caso, iremos executar o comando da linha 42. De qualquer forma em algum momento, seja nesta linha 42, seja na linha 46 iremos finalizar o laço. No entanto, em nenhum destes momentos iremos executar a linha 53. Voltando assim para a linha oito. Neste ponto temos a expressão sendo analisada. Porém você pode estar pensando: Mas switch não iria analisar a expressão de forma numérica? Por que os valores em CASE são do tipo booleano? Isto não faz sentido para mim. Mas esta é a questão meu caro leitor. Quando expliquei sobre o comando IF, falei sobre o que tornar um valor verdadeiro ou falso. Com relação ao valor falso, nada muda aqui. Porém para o valor verdadeiro as coisas são um pouco diferentes. Isto por que, o valor TRUE que você pode ver na linha dez, é na verdade o valor UM. Ou seja, se a função Tic_Tac, retornar um valor que seja, zero ou um. Este comando switch da linha oito irá conseguir entender, e uma das mensagens será mostrada. Porém, se você modificar a função Tic_Tac, de forma que ela retorne um outro valor, que NÃO SEJA, zero ou um. Este switch da linha oito, não irá encontrar nenhuma correspondência associada ao valor de retorno. E neste caso, nenhuma mensagem será mostrada.

Porém vale ressaltar o seguinte fato. Se no lugar deste switch da linha oito, você vier a utilizar um comando IF, alguma mensagem pode ser mostrada. Isto dependendo de como você implemente o comando IF. Como o objetivo, aqui, é justamente fazer com que você comece a pensar como um programador. Não irei mostrar, como você deverá proceder neste caso. Apenas estou mencionando estes fatos, para que você comece a pensar como um programador. E procure entender, o que cada comando de fato efetua e as capacidades, assim como as limitações de cada um dos comandos de controle de fluxo.

Considerações finais

Neste artigo, foi visto como seria um comando switch. Sei que a princípio este comando parece mais gerar confusão e complicar o código, do que realmente nos ajudar a programar e implementar nossas soluções. Mas quero ressaltar mais uma vez. Procure estudar cada comando aos poucos. Tentando fazer a mesma coisa, só que de formas ligeiramente diferente. Isto lhe ajudará a entender como cada coisa vai sendo montada aos poucos.

Comece desta forma, aos poucos, não tenha pressa em começar a criar, um indicador ou mesmo um Expert Advisor. Construa uma base solida de conhecimento, antes de procurar se aventurar em coisas mais elaboradas. Assim, todo o seu trabalho será muito menor e o seu esforço será melhor recompensado. Então aproveite e estude os códigos que estarão n anexo. E nos vemos no próximo artigo.