Do básico ao intermediário: Variáveis (I)

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.

Aqui vamos começar um estilo de artigo, cujo objetivo é ajudar e explicar certos conceitos e utilização do MQL5 para diversas atividades. Não apenas focado em criar indicadores, scripts ou mesmo Expert Advisores. O proposito principal aqui, é levar e divulgar conhecimento.

Muitos de vocês já me conhecem de outros artigos, que tenho publicado. Porém, como aqueles artigos, são voltados para programadores com alguma experiência. E muitos tem me mostrado interesse em começar a estudar de maneira mais séria sobre o assunto. Achei válido, criar um outro perfil para dar algumas explicações básicas sobre o tema. Não que aqui iremos tratar de coisas que muitos já sabem, tornando os artigos chatos e sem proposito. Pelo contrário, irei tentar trazer artigos que sejam realmente interessantes e divertidos. Mas como já existem uma grande quantidade de artigos no outro perfil, esperando apenas para serem publicados. E tendo interesse em passar um pouco mais do meu conhecimento a todos. Então irei alimentar este perfil com novos artigos. Os assuntos aqui, serão focados a ir do básico ao que considero ser um nível intermediário. Mas iremos explorar diversas coisas dentro do MQL5. E algumas das coisas, inclusive servirão para quem pretende estudar outras linguagens de programação.

Assim neste primeiro artigo, vamos começar com a parte mais básica e fundamental, presente na programação em geral. O tema será: Variáveis. Mas como gosto se separar adequadamente as coisas, vamos iniciar um novo tópico, para de fato começar o artigo.

Variáveis. A base da programação

Muita gente acredita, de maneira errônea, que programas de computadores, são criados em cima de funções e procedimentos. Porém este tipo de coisa é um equívoco. Programas de computadores, são criados e pensados, visando basicamente as variáveis. Nenhum programa, por mais elaborado que venha a ser, é criado ou proposto, visando outro tipo de coisa. O objetivo sempre é fazer com que uma variável venha e possa ser conhecida.

Pode parecer estranho dizer isto. Ainda mais quando, em cursos e livros, todos procuram focar em funções e procedimentos. Dando a entender que aqueles são os princípios básicos envolvidos na programação. No entanto, não estou aqui para causar polemica ou desavença. Estou aqui para agregar. Sendo assim, apesar destes termos conhecidos como funções e procedimentos, serem de grande importância. Eles não passam de algum tipo de variável sendo computada. Isto irá ficar mais claro no decorrer dos próximos artigos.

Porém, neste artigo de agora, o objetivo é apresentar a você, meu caro leitor, o conceito de variáveis. E sim, existem diferenças entre variáveis. Saber o que cada tipo representa, e como podemos fazer o melhor uso de cada uma. É a diferença entre um programa bem escrito e um mero programa que efetua uma dada tarefa.

Para começar existem dois tipos diferentes de variáveis. As que podem mudar de valor e as que não podem mudar de valor. Neste segundo caso, o mais correto é chamar o tipo de constante. Porém, como programas de computador executando em modo usuário, sempre estarão presentes em RAM. A palavra constante, não é assim tão adequada. Isto por que, pelo simples fato de que o valor está em RAM, ele pode ser modificado de alguma maneira. Quem nunca usou um CRACK para burlar alguma limitação? Pois bem, em muitos casos o CRACK, atua diretamente em alguma parte do executável. Seja quando ele está na memória RAM, seja quando ele ainda está em disco.

Quando a atuação é feita em disco, o CRACK, estará atuando diretamente em cima de constantes. Isto por que, os valores presentes no disco, não mudam conforme o tempo passa. Eles tendem a permanecer inalterados. Assim o CRACK, de fato estará atuando em um valor, que parece ser constante. Porém é variável, justamente por conta que o CRACK consegue modificar o mesmo. No entanto, quando em memória RAM, algumas partes, podem ser tratadas como sendo constantes. Sendo que a tentativa de modificar tal valor será considerado um erro. E o processador irá notificar o sistema operacional para que ele tome as devidas providencias. Assim sendo, este é o primeiro ponto a ser observando. Variáveis, podem ser constantes ou não. Se os valores estão em RAM, nossa aplicação pode dizer, o que será constante e o que será variável. Em qualquer outro cenário, variáveis nunca serão e deverão ser pensadas como constantes.

Muito bem, feita esta pequena diferenciação, apenas de maneira conceitual. Podemos passar para uma próxima etapa. Onde este mesmo conceito, será de fato colocado em prática. Então vamos começar com calma. Mesmo por que, certos conceitos, são um tanto quanto difíceis de serem separados. O que torna tudo no primeiro momento algo bastante complicado de entender. Mas tenha paciência meu caro leitor. Em breve, você se sentirá mais seguro e confiante. Assim será capaz de fazer diversas coisas com muito mais facilidade. É só ir estudando as coisas aos poucos. Começando pelo que é mostrado logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     int     value1;
07.     char    value2;
08.     long    value3;
09. 
10.     value1 = 10;
11.     value2 = 5;
12.     Print("Result: ", value1 + value2 + value3);
13. }
14. //+------------------------------------------------------------------+

Código 01

Este código 01 é muito simples e básico. Aqui temos três declarações de variáveis. Elas estão nas linhas 06, 07 e 08. Por enquanto, não se preocupe com a questão de tipos. Em outro artigo iremos abordar isto com mais calma. No momento, se atente apenas ao que será explicado. Apesar de termos três variáveis sendo declaradas, duas delas na verdade são constantes temporárias. E outra não está sendo referenciada, ou inicializada como é o termo correto a ser utilizado aqui. Muitas vezes, você imagina que este código irá produzir um certo resultado. Porém o fato de não entender como as coisas funcionam, ou de as ignorar, pode por todo o seu trabalho em risco.

Para compreender isto, vejamos as saídas que são produzidas pelo compilador. No caso de você estar utilizando o MetaEditor, a saída irá se parecer com a imagem 01, vista logo abaixo.

Imagem 01

Já no meu caso, que utilizo uma outra ferramenta para editar os códigos. Porém que faz uso do compilador do MetaTrader 5, para criar as aplicações. O resultado é como o mostrado logo abaixo.

Imagem 02

Observe que em ambos casos, o compilador está nos gerando um alerta. E você deve tomar cuidado quando estes alertas forem emitidos. Isto por que, em muitos casos, indicará que sua aplicação poderá funcionar de maneira não esperada. Quando acontecer de eu mostrar, algumas coisas referentes a saída do compilador, irei fazer isto, conforme o modelo visto na imagem 02. No entanto, o resultado será muito parecido com as mensagens que você verá se estiver utilizando o MetaEditor. Então é só prestar um pouco de atenção que você conseguirá acompanhar cada um dos artigos.

Muito bem, agora supondo que você ignore este aviso do compilador. Alguns pode ser ignorado, enquanto outros NÃO. E você venha a executar esta aplicação, já compilada no MetaTrader 5. Que tipo de resultado você espera obter? Bem, obviamente você espera conseguir o valor 15. Já que na linha 10, estamos dizendo que a variável value1 é igual a dez e na linha 11 que a variável value2 é igual a cinco. Assim quando a linha 12 vier a ser executada, o resultado esperado é a soma destes dois valores. Correto? Bem, vejamos. O resultado é visto logo abaixo.

Imagem 03

Credo. Mas o que aconteceu aqui? Você tá de sacanagem? Não meu caro leitor. Isto não é nenhuma sacanagem. É um fato que você poderá comprovar. Mas seu espanto não é de se estranhar. Já que você claramente esperava que o valor impresso de fato fosse igual a 15. Mas por que está sendo gerado este valor zero? O motivo é justamente a variável value3. Por ela participar do cálculo e NÃO TER SIDO devidamente inicializada. Ela pode estar com qualquer valor. E dependendo deste valor, que em programação chamamos de "lixo", ela irá fazer com que o resultado final fique incorreto.

Ok, neste caso temos duas alternativas. A primeira é inicializar o valor de value3 de maneira correta. A segunda é remover value3 do cálculo que está sendo feito na linha 12. Como o nosso objetivo, neste momento é gerar o resultado 15. A segunda alternativa é a que iremos empregar. Assim o mesmo código 01, terá a sua linha 12, modificada para o que você pode observar logo abaixo.

Print("Result: ", value1 + value2);

Neste caso, quando você tentar compilar o código, o compilador irá gerar o seguinte tipo de alerta.

Imagem 04

Perceba que o alerta é diferente do que foi visto anteriormente. Então depois de ponderar sobre o mesmo, você decide que este em especial pode ser ignorado. Assim executa a aplicação no MetaTrader 5, e obtém o resultado visto logo abaixo.

Imagem 05

Sucesso. Conseguimos exatamente o esperado. Agora vamos voltar, ao código 01 original, para compreender alguns conceitos básico. Como foi dito anteriormente, as variáveis value1 e value2, são e devem ser pensadas como constantes temporárias. Mas por que? O motivo é justamente o fato de que elas NÃO mudam de valor durante todo o código. Elas permanecem com o mesmo valor o tempo todo. Porém, existe uma questão aqui, e é neste ponto que as coisas começam a ficar um pouco mais interessante.

Apesar de value1 e value2, assim como value3 serem variáveis. Você, como programador pode mudar isto. Garantindo assim que um valor aplicado em uma dada variável NÃO IRÁ MUDAR. Isto independentemente de algum deslise que você possa vir a cometer durante o processo de codificação. Muitos programadores mais experientes e mexendo com códigos mais elaborados e complexos, gostam de usar linguagens que permitem este tipo de controle. Onde você, como programador, pode dizer: Olha compilador, esta variável daqui, não deve ser vista como variável. Eu quero que ela seja uma constante. E o compilador irá lhe ajudar a garantir que uma dada variável, permaneça como sendo uma constante. Para fazer este tipo de coisa, em MQL5, fazemos uso de uma palavra reservada. Assim, um código, cujo resultado deverá o mesmo obtido anteriormente, poderia ser escrito de uma outra maneira. Mas antes de vermos isto sendo aplicado na prática. Vamos ver uma outra coisa. Assim criamos o código que é visto logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     const int   value1;
07.     char        value2;
08. 
09.     value1 = 10;
10.     value2 = 5;
11.     Print("Result: ", value1 + value2);
12. }
13. //+------------------------------------------------------------------+

Código 02

Se você tentar compilar este código 02, irá ser impedido pelo compilador. Justamente por conta dos erros visto logo abaixo.

Imagem 06

Neste caso, você nota que estamos tendo dois erros. Um que está sendo gerado na linha seis e outro na linha nove. Mas vamos entender, o que cada erro significa. Pois mais importante do que simplesmente corrigir os erros. É entender o que eles querem nos dizer. Pois nem sempre um erro é um erro de fato. Muitas vezes, ele pode ser um simples aviso do compilador, nos dizendo que estamos tentando fazer algo que não deveria ser feito. E este é ocaso do erro indicado na linha nove.

Agora preste atenção, pois isto pode lhe ajudar bastante na programação em MQL5. Quando você define uma variável como sendo uma constante. Qualquer tentativa de mudança no seu valor, durante a execução do código será considerado um erro GRAVE. Porém ainda não estamos executando a nossa aplicação. No entanto, o compilador do MQL5, já está nos alertando para esta possibilidade de um erro grave durante a execução. Devido a isto, ele impede que o código 02 venha a ser compilado. Isto por que, você, como programador, disse ao compilador que a variável value1 NÃO é uma variável. Mas sim uma CONSTANTE. E fez isto ao usar a palavra const antes da declaração, que você pode observar na linha seis do código 02. Muitos programadores com menos experiência, iriam remover a palavra const da declaração da linha seis. Isto não é um erro. Porém ao fazer isto, você já não terá ajuda do compilador, para impedir que a variável value1 seja tratada como uma constante. Podendo assim ter outros tipos de problema com a sua aplicação. Como por exemplo, a geração de valores incorretos em determinados momentos. Sem de fato entender por que o código não está se comportando da maneira adequada.

Mas aqui entra outra questão, é esta é justamente a que origina o erro na linha seis, como você pode observar na imagem 06. Esta mesma questão é a que fazia o código 01, gerar um valor incorreto durante a execução. Quando a variável value3 era utilizada no cálculo da linha 12. Isto olhando o código 01.

A tal questão é justamente a inicialização de valores. Algumas linguagens de programação, fazem uma inicialização dos valores. Normalmente com um valor padrão que é zero. Porém ao fazer isto, os desenvolvedores do compilador devem tomar alguns cuidados. Como evitar de que variáveis que serão tratadas como constantes, não tenha um valor definido de maneira explicita. O fato de simplesmente colocar, ou atribuir de maneira arbitrária e implícita o valor zero, para toda e qualquer variável não inicializada, pode ser prejudicial a aplicação final. Justamente por conta deste detalhe mostrado no código 02. Onde se o compilador viesse a atribuir o valor zero para toda variável não inicializada. Faria com que o resultado da operação da linha 11 ficasse completamente errado. E você, como programador, acabaria perdendo muito tempo tentando entender por que. Então, nem sempre um erro é de fato um erro. Assim como um alerta nem sempre precisa ser corrigido. Em alguns casos podemos ignorar certos detalhes que nos são reportados.

Muito bem, tendo deixado isto claro. Com então o código 02, deveria ser escrito para que ele pudesse ser compilado? Bem, meu caro leitor, levando em conta que de fato queremos as coisas daquela forma, ele deveria ser modificado para o código visto logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     const int   value1 = 10;
07.     char        value2;
08. 
09.     value2 = 5;
10.     Print("Result: ", value1 + value2);
11. }
12. //+------------------------------------------------------------------+

Código 03

Agora sim. Este código 03 de fato será compilado e o resultado será o mesmo que pode ser visto na imagem 05. Mas talvez uma dúvida tenha surgido em sua mente. Por que programar algo como visto até este momento? Não seria mais simples e fácil, simplesmente usar algo como mostrado logo abaixo.

1. #property copyright "Daniel Jose"
2. //+------------------------------------------------------------------+
3. void OnStart(void)
4. {
5.     Print("Result: ", 10 + 5);
6. }
7. //+------------------------------------------------------------------+

Código 04

Sim meu caro leitor. Em alguns casos, programar algo como mostrado no código 04, é de fato a maneira mais simples. Visto que estamos lidando exclusivamente com constantes. Porém nem sempre este tipo de coisa é de fato desejável. Isto por que, constantes numéricas são frias e não nos passa um conhecimento sobre o motivo de sua existência. Olhando para este código 04, você conseguiria dizer, qual é o motivo pelo qual os valores dez e cinco estão sendo utilizados? Talvez você esteja efetuando alguma fatoração a fim de descobrir um resultado, a princípio desconhecido. Ok. Se este for o motivo, você estará fazendo uso de um outro tipo de variável. Uma que será explicada em detalhes em outro artigo. No entanto, se este não for o motivo. Com o tempo, você irá se questionar por que daquele cálculo está sendo feito. E ao fazer isto, poderá acabar tendo dificuldades em entender seu próprio código.

Justamente devido a este fato, é que diversos programadores pelo mundo a fora, fazem uso de determinados recursos da linguagem que está sendo utilizada. No caso em questão, onde estamos começando a falar sobre o assunto, e assim explicar como programar de uma forma melhor. O uso de variáveis é a melhor escolha neste momento. Isto por que, você pode dar um nome adequado a ela, e mesmo depois de muito tempo, irá conseguir compreender o proposito daquele valor. Mesmo que a variável tenha sido implementada como sendo uma constante.

Acredito que este primeiro ponto tenha sido devidamente esclarecido. Isto de maneira que você, meu caro leitor, consiga entender por que em alguns momentos, dizemos que uma variável é uma constante e em outros não. E o que este tipo de declaração fará com as nossas estimadas variáveis. Como ainda temos espaço para falar um pouco mais sobre o assunto. Vamos mudar de tópico, mas mantendo ainda dentro do que está relacionado a questão básica sobre variáveis.

Tempo de vida e visibilidade

Uma coisa que costuma quebrar muita gente, mesmo pessoas com uma boa experiência em programação é o tempo de vida de variáveis. Assim como também a visibilidade das mesmas. No entanto, apesar de parecer assuntos diferentes, ambos podem ser tratados juntos. Isto por que, tanto o tempo de vida quanto a visibilidade estão de certa forma correlacionados. Sendo que a visibilidade é algo bem mais abrangente e que será explicado melhor em vários outros artigos no decorrer do tempo. Isto por que existem algumas questões relacionadas a visibilidade que afetam imensamente a forma como uma aplicação deve ser pensada. Mas isto será visto em um momento oportuno.

No momento atual, vamos nos manter na parte mais básica de todas. Ou seja, quando uma variável nasce e onde ela morre. E se existe uma forma de impedir de ela morrer.

Para não complicar as coisas, de maneira inicial. Vamos fazer algumas considerações. A primeira e a mais simples é a de que:

Uma variável nasce no momento de sua declaração.

Parece obvio esta frase. Mas as coisas começam a ficar um pouco mais confusas, quando olhamos isto pela ótica da visibilidade de uma dada variável. Mas antes de fazermos isto de maneira mais aprofundada. Vamos ver um caso simples. Para isto, iremos utilizar o código visto logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     const int value1 = 10;
07.     int value2;
08. 
09.     value2 = 5;
10.     {
11.         int value2;
12. 
13.         value2 = 8;
14. 
15.         Print("Result #01: ", value1 + value2);
16.     }
17.     Print("Result #02: ", value1 + value2);
18. }
19. //+------------------------------------------------------------------+

Código 05

Antes de executar este código 05. Você meu caro leitor, conseguiria responder qual será o valor que iremos imprimir no terminal? Isto quando as linhas 15 e 17 forem executadas. Ou será que este código se quer será compilado. Bem, antes que você comece a ter devaneios sobre isto. Sim. Este código será compilado e executado. Porém existe uma questão a ser entendida aqui. Esta é a primeira de várias que você precisará entender no decorrer desta jornada.

Quando o código 05 for executado, você verá o resultado mostrado logo na imagem abaixo.

Imagem 07

Agora lhe pergunto novamente: Você consegue entender estes resultados? Bem, isto daqui é apenas uma pequena brincadeira, frente ao que podemos de fato fazer. Muitos programadores, mesmo com bastante experiência, evitam colocar nomes iguais em variáveis colocadas dentro de um mesmo bloco de código. Só que aqui, não estamos usando um bloco de código, mas sim dois. Mas como assim? Você endoidou, ou está viajando na maionese, ao disser que temos dois blocos de código aqui no código 05? Não meu caro leitor, apesar da idade, ainda não perdi o juízo. O detalhe e que já estou introduzindo um assunto que será melhor entendido em um outro momento. Mas aqui no MQL5, assim como em outras linguagens baseadas em C e C++, cada bloco de código se inicia em um abre chave { e finaliza em um fecha chave }.

Qualquer coisa presente entre estes dois símbolos é e deverá ser considerado um bloco de código. Existem outras formas de definir um bloco de código, como no caso de laços. Mas esta, das chaves, é a mais simples de entender. Então um bloco se inicia na linha cinco e termina na linha dezoito. Já o outro bloco se inicia na linha dez e finaliza na linha dezesseis. Entendido isto, vamos matar dois assuntos de uma só vez.

O primeiro, é o fato de que uma variável jogada no código, inicia sua vida no momento de sua declaração. E termina sua vida, no momento que o bloco na qual ela pertence deixa de existir. Existe uma exceção a isto. Mas não se preocupe com isto neste momento. Apenas tente entender este conceito mais simples, com que estamos trabalhando neste momento. O segundo fato é que, qualquer coisa fora de um bloco, é e deverá ser considerado como algo global, dentro do bloco ao qual pertence.

Este segundo fato é um pouco mais complicado de entender logo de cara. Mas vamos dar um passo de cada vez. Primeiro vamos entender, por que o código 05, nos gera o resultado que é visto na imagem 07. Com base nas declarações feitas acima, podemos ver que na linha sete e linha onze, uma variável com o mesmo nome está sendo declarada. E nas linhas nove e treze, estamos definindo valores diferentes a uma variável, que teoricamente nos parece ser a mesma coisa. Porém se você prestar atenção ao código, notará que elas estão em blocos diferentes. Sendo que uma está em um bloco e a outra está em um bloco interno ao primeiro.

De maneira bastante simplista, o bloco onde declaramos value2, na linha sete, é um bloco global. Assim value2 que está sendo declarada na linha sete, É UMA VARIAVEL GLOBAL. Já a variável value2 que está sendo declarada na linha treze, é uma variável local. Isto olhando para fora do bloco. Mas dentro do bloco que começa na linha dez, esta variável declarada na linha onze é uma variável global.

Sei que isto é um tanto quanto confuso. Então pare um pouco e reflita sobre isto. Pois entender este conceito é EXTREMAMENTE IMPORTANTE. Isto por que, você não está obrigado a usar nomes diferentes o tempo todo. O compilador exige que você utilize nomes diferentes para variáveis dentro do mesmo bloco. Mas se elas estão em blocos diferentes, o compilador aceita que tenhamos o mesmo nome, para variáveis distintas.

Mas então, por que motivos estamos tendo dois valores no resultado final? O motivo é simples, meu caro leitor. A variável local, irá ter prioridade sobre a variável global. Isto quando ambas tiverem o mesmo nome, independentemente do tipo. Se o nome é o mesmo, o compilador irá preferir utilizar a variável local. Mas tenha cuidado. Algumas linguagens podem utilizar uma metodologia diferente. O que estou dizendo aqui, se aplica ao MQL5. Já que o foco aqui é justamente esta linguagem em particular.

Com isto fica simples de entender o seguinte fato: Quando na linha treze, dizemos que value2 é igual a 8. Isto não irá destruir o valor que value2 tem no âmbito global. Que é o valor de 5, que foi definido na linha nove. Por conta disto, quando usamos a linha 15 para imprimir o resultado de value1 somado com value2, obteremos dezoito no primeiro caso. E quando a linha 17 fizer o mesmo cálculo, o valor será igual a quinze.

Porém, se você tentar fazer algo parecido, mas usando um código como o que podemos ver logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     const int value1 = 10;
07.     int value2;
08. 
09.     value2 = 5;
10. 
11.         int value2;
12. 
13.         value2 = 8;
14. 
15.         Print("Result #01: ", value1 + value2);
16. 
17.     Print("Result #02: ", value1 + value2);
18. }
19. //+------------------------------------------------------------------+

Código 06

O compilador irá reclamar, lhe mostrando algo parecido com o que é visto na imagem 08, logo abaixo.

Imagem 08

Isto por que, diferente do código 05, este código 06 conta com somente um único bloco. Que se inicia na linha cinco e termina na linha 18. Portanto tome cuidado quando estiver programando, ou tentando entender o que um outro programador escreveu. E por que suas tentativas de modificar o código não tem tido sucesso.

Entretanto, pode ser que você esteja lidando com uma situação um pouco diferente. Esta pode ser observada no código logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. int value2;
05. //+------------------------------------------------------------------+
06. void OnStart(void)
07. {
08.     const int value1 = 10;
09. 
10.     value2 = 5;
11. 
12.         int value2;
13. 
14.         value2 = 8;
15. 
16.         Print("Result #01: ", value1 + value2);
17. 
18.     Print("Result #02: ", value1 + value2);
19. }
20. //+------------------------------------------------------------------+

Código 07

Neste caso o compilador irá lhe mostrar uma mensagem muito parecida com a que pode ser observada na imagem 09, logo abaixo.

Imagem 09

Ok. Olhando para esta mensagem, presente na imagem 09. Qual atitude você deverá tomar, tendo em vista o código 07, porém com o objetivo de um resultado igual a imagem 07? Bem, meu caro leitor, este é um ponto, onde realmente as coisas ficam extremamente complicadas. Visto que a declaração de value2, que está sendo feita na linha quatro, somente irá morrer, quando a aplicação vier a deixar de existir. Ou de ser executada. Por conta disto, neste tipo de cenário, NÃO DEVEMOS usar variáveis com escopo local, junto com uma com o mesmo nome, porém com um escopo global.

Como via de regra, variáveis, ou valores globais são um problema a parte. Algo que você deverá evitar a todo custo. É bem verdade que nem sempre isto será possível de ser feito. Mas se este tipo de coisa vier a ocorrer, ou não houver uma outra alternativa. Você deverá usar nomes diferentes para as variáveis. Muitos programadores, assim como eu, costumam colocar algum prefixo ou sufixo a fim de distinguir variáveis globais, que existirão durante toda a vida do programa, de variáveis locais, ou mesmo globais pertencentes a um bloco específico.

Considerações finais

Este está sendo o primeiro artigo, em que meu foco será explicar a você, seja iniciante ou mesmo um programador casual. Como trabalhar de uma forma mais adequada e produtiva utilizando o MQL5. O foco aqui será única e exclusivamente a passagem de um pouco da minha experiência como programador profissional. Mostrando a você, como proceder a fim de conseguir criar seus próprios códigos de maneira, simples, eficiente e sem muitos solavancos.

Programação é algo memorável e maravilhoso. Se for bem orientada e com um conhecimento criado de forma sólida e consistente. Irá com toda a certeza lhe trazer bons frutos no futuro. Então no próximo artigo, iremos continuar a tratar sobre a questão das variáveis. Pois aqui apenas apresentei qual será a metodologia a ser utilizada nos próximos artigos. Espero que você tenha gostado. E se desejar visualizar um material um pouco mais avançado, com uma metodologia parecida. Veja meus outros artigos, presentes aqui na comunidade, só quem em outro perfil.