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

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: Variáveis (I), começamos a falar sobre variáveis e algumas coisas relacionadas a elas. Como por exemplo, o fato de podermos transformar variáveis em constantes. Assim como também começamos a falar sobre o tempo de vida e a visibilidade das variáveis.

Aqui iremos continuar aquele ponto, partindo do pressuposto de que você conseguiu compreender de maneira adequada aquele material inicial. Pois bem, dentro da questão envolvendo o tempo de vida e a visibilidade de variáveis. Temos algo que para muitos iniciantes é um pouco complicado de entender. Isto por que, em muitos casos, NÃO QUEREMOS variáveis globais nos atrapalhando. Queremos que as variáveis venham a existir dentro de um bloco de código. Mas, e é neste ponto que as coisas começam a complicar, NÃO QUEREMOS que o valor de uma variável morra, ou desapareça, quando o bloco terminar.

Este tipo de coisa, na qual acabei de mencionar, é uma das que mais gera confusão na mente de muitos programadores casuais, ou mesmo iniciantes que pretendem se profissionalizar. Isto por que, muitos não conseguem compreender o conceito de que, existem mecanismos em certas linguagens de programação, que permite uma variável manter em memória o seu valor. Este tipo de dificuldade, muito provavelmente se deve justamente ao fato de que, linguagem de script populares como Python, não fazem uso de tal implementação. Assim um programador, acostumado a trabalhar em Python, tem uma imensa dificuldade de entender este conceito. Variáveis, nem sempre perdem, ou melhor dizendo, esquecem seu valor, quando o bloco na qual elas pertencem, deixa de existir.

Porém programadores C/C++ tem este conceito bastante solidificado em suas mentes. E como o MQL5, deriva de tais linguagem, ele acabou adotando este mesmo tipo de conceito. O que ao meu ver é uma coisa muito boa. Já que de outra forma, seria necessário trabalhar com variáveis globais no âmbito da aplicação. O que em muitos casos é um tremendo de um inconveniente.

Muito bem, então para explicar como este tipo de coisa funciona. Vamos iniciar um novo tópico.

Variáveis estáticas

Variáveis estáticas é um dos conceitos mais poderosos, e ao mesmo tempo mais complicados de serem compreendidos por uma ampla gama de programadores iniciantes. Isto por que, à primeira vista elas não fazem muito sentido. Porém conforme você as estuda e passa a compreender seu funcionamento. Mas principalmente os momentos em que elas podem e são aplicadas. Você passa a sentir um profundo amor pelas mesmas. Já que elas resolvem muitos problemas, que de outra maneira, seria muito mais trabalhoso d serem resolvidos.

Para começar, vamos ver um caso bastante simples. Porém, apesar de não termos entrado ainda em certos conceitos de programação. Quero que você não procure se preocupar com outras coisas que não seja variáveis. Esqueça todo o resto e procure entender o que está ocorrendo com as variáveis. Pois este será o ponto realmente importante aqui.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     uchar counter = 0;
07.     ulong value = 1;
08. 
09.     Print("Factorial of ", counter, " => ", value);
10.     counter = counter + 1;
11.     value = value * counter;
12.     Print("Factorial of ", counter, " => ", value);
13.     counter = counter + 1;
14.     value = value * counter;
15.     Print("Factorial of ", counter, " => ", value);
16.     counter = counter + 1;
17.     value = value * counter;
18.     Print("Factorial of ", counter, " => ", value);
19.     counter = counter + 1;
20.     value = value * counter;
21.     Print("Factorial of ", counter, " => ", value);
22. }
23. //+------------------------------------------------------------------+

Código 01

Eu sei, poderíamos usar um laço aqui. Mas vamos considerar que você está de fato começando do zero a aprender programação. Não sabe absolutamente nada sobre o assunto e que tudo que sabe foi visto no artigo anterior. Assim sendo, precisamos ir do começo. É um pouco mais complicado neste início, mas logo as coisas ficarão melhores.

Tudo bem, o grande detalhe aqui é o seguinte: Quando executarmos este código 01 no terminal do MetaTrader 5, teremos como resultado o que pode ser visto logo abaixo.

Figura 01

Ótimo, como você pode ver, funciona. O que estamos fazendo aqui é calculando o fatorial de um número. Só que ao invés se fazer isto e apenas devolver o resultado, estamos calculando-o, passo a passo. Este fato é importante para você entender onde quero chegar.

Agora perceba o seguinte meu caro leitor. Na linha seis, criamos e já inicializamos uma variável. Esta irá contar qual é o atual fatorial que estaremos calculando. Já na linha sete, declaramos também uma variável e já a inicializamos com o valor adequado. E sim, o fatorial de zero é um, assim como também o fatorial de um também é igual a um. Ter este conhecimento é importante para efetuar qualquer trabalho de programação. Já que programação envolve resolver as coisas de forma matemática. Ao contrário do que muitos pensam, de que programação é simplesmente digitar um monte de coisas e fazer o computador as executar. O trabalho do programador, em essência consiste em transformar fórmulas matemáticas em código que a máquina consiga compreender. Por isto saber matemática é primordial para ser um bom programador.

Voltando a nossa questão, nas linhas 09, 12, 15, 18 e 21 imprimimos os resultados de forma legível a nos humanos. E entre cada um destes passos, dizemos a máquina como ela deverá fazer para calcular o próximo valor. Agora preste atenção ao seguinte fato: Cada vez que calculamos o fatorial do atual número, usamos o valor do fatorial anterior. Ou seja, mesmo que inicialmente counter e value sejam constantes, a cada novo pedido de cálculo, aqueles valores que eram antes constantes mudam, passando a ser uma nova constante. Este é o conceito mais singular sobre variáveis que você deverá levar para o resto de sua vida, como programador.

Bem, agora que estamos em um mesmo barco, podemos tentar deixar as coisas mais simples, fazendo uso de menos linhas de código. Para fazer isto, precisaremos utilizar um outro conceito. Que apesar de vir a ser explicado de maneira mais adequada futuramente, será necessário neste momento. O conceito em si é o de rotina.

Uma rotina, basicamente seria algo que a máquina deverá fazer toda vez que mandarmos ela fazer. Seria como se fosse uma tarefa chata e repetitiva. Da qual não queremos ficar digitando a todo momento em forma de código. Tipo o que acontece, em diversas linhas no código 01. Existem basicamente dois tipos de rotinas. As funções e os procedimentos. Mas aqui para explicar as variáveis estáticas, iremos utilizar um procedimento. Isto por que fica mais simples compreender o que estará ocorrendo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. uchar counter = 0;
05. ulong value = 1;
06. //+------------------------------------------------------------------+
07. void OnStart(void)
08. {
09.     Factorial();
10.     Factorial();
11.     Factorial();
12.     Factorial();
13.     Factorial();
14. }
15. //+------------------------------------------------------------------+
16. void Factorial(void)
17. {
18.     Print("Factorial of ", counter, " => ", value);    
19.     counter = counter + 1;
20.     value = value * counter;
21. }
22. //+------------------------------------------------------------------+

Código 02

Agora observe que este código 02 é muito mais simples de ser compreendido. Logo de cara, você nota que estamos calculando o valor de fatorial que vai de zero até quatro. Isto por que temos quatro chamadas, ao procedimento Factorial, dentro do que é o bloco principal do código, ou seja, o procedimento OnStart. Como eu mencionei, futuramente iremos falar mais sobre este tipo de coisa. Mas por hora, vamos entender as variáveis.

Note, que apesar da aparente diferença entre o código 01 e o código 02. Ambos terão como resultado a figura 01. Porém, aqui no código 02, estamos fazendo uso de duas variáveis globais. Que irão nascer quando o código é posto em execução e irão morrer somente depois que o código for finalizado. Entre um momento e outro, estas mesmas variáveis poderão ser modificadas por qualquer procedimento ou função que as estejam vendo. Mesmo que a mudança venha a ser por conta de uma falha sua, por distração durante o processo de implementação do código. O que não é raro de ocorrer em códigos complexos.

No entanto, mesmo sendo variáveis globais, não pertencendo a nenhum bloco específico. Estes valores precisam ser inicializados. Como você pode ver, ela está sendo inicializada no momento em que as estamos declarando. No entanto isto poderia ser feito em qualquer outro momento. Tornando assim difícil rastrear possíveis mudanças em seus valores. Mas para simplificar, estou as inicializando logo na declaração. Por conta disto, neste exato momento, surge uma pergunta, perfeitamente plausível. Se estou projetando algo, que ao meu ver é muito complexo. E tenho receio de mudar os valores de alguma variável global, por conta de alguma distração, durante a codificação da minha aplicação. Não seria melhor declarar as variáveis counter e value, dentro do procedimento Factorial ?!?! Assim eu não correria o risco de mudanças nestas variáveis, por conta de algum momento de distração.

Sim meu caro leitor, a melhor ideia de fato, seria remover counter e value do âmbito global e as colocar dentro do procedimento Factorial. Assim teríamos um melhor controle sobre as variáveis presentes no código. Então vamos fazer isto e ver o que acontece. Pois aparentemente tanto o código 01, quanto o código 02, funcionam. E se funcionam, significa que estamos no caminho certo. Assim efetuando a mudança mencionada, teremos o seguinte código visto logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     Factorial();
07.     Factorial();
08.     Factorial();
09.     Factorial();
10.     Factorial();
11. }
12. //+------------------------------------------------------------------+
13. void Factorial(void)
14. {
15.     uchar counter = 0;
16.     ulong value = 1;
17. 
18.     Print("Factorial of ", counter, " => ", value);    
19.     counter = counter + 1;
20.     value = value * counter;
21. }
22. //+------------------------------------------------------------------+

Código 03

Legal, agora não temos mais o problema de variáveis globais no âmbito do código. Nosso programa de fato ficou muito mais organizado. Mas e quanto ao resultado ?!?! Será que ainda estamos calculando os valores de fatorial entre zero e quatro ?!?! Bem, vejamos. Depois de compilar o código e o executar no terminal do MetaTrader 5. O seguinte resultado nos será apresentado:

Figura 02

Ué. Não funcionou. Mas por que ?!?! Se estava funcionando antes. Agora de fato não entendi, já que aparentemente estamos executando cinco vezes como era esperado. No entanto, parece que estamos o tempo todo apontando para os mesmos valores. Hum, deixe-me pensar um pouco. Calma aí.

Saquei o que está ocorrendo, cada vez que estamos executando uma das chamadas presentes no que você falou ser o bloco principal, que é OnStart. Estamos declarando novamente a variável counter e a variável value. E ao fazermos isto, também estamos as inicializando com os valores iniciais vistos nos demais códigos acima. Aí está o motivo de não ter funcionado. Então agora entendi o que seria o chamado bloco de vida de uma variável. Mas ainda estou com uma dúvida: E se eu NÃO informar o valor ali nas linhas 15 e 16. Talvez funcione !! Não meu caro leitor, você pode até experimentar fazer isto. Mas acabará caindo nas questões que foram abordadas no artigo anterior.

Então poderíamos passar os valores para o procedimento. Assim funcionaria. Sim neste caso funcionaria. Porém, você estaria passando o carro na frente dos bois. Como ainda não foi explicado como passar valores entre procedimentos e funções, você não pode ainda, utilizar este tipo de recurso. Precisa bolar uma outra maneira de fazer com que este código 03, venha a funcionar e nos mostrar as mesmas informações que podem ser vistas na figura 01. E não está coisa bizarra, que vemos ao olhar a figura 02. E então desiste ?!?!

Bem, se este foi o caso, chegou a hora de acabar com este seu sofrimento. Para resolver o problema, sem fazer uso de nenhuma solução mágica, e mantendo as variáveis counter e value, dentro do procedimento Factorial. Precisamos usar o que é conhecida como sendo uma variável estática. Ao fazermos isto, a variável que estiver declarada como estática, NÃO perderá seu valor durante chamadas distintas a um mesmo procedimento ou função.

Parece algo muito complicado não é mesmo ?!?! Mas na prática a coisa é bem mais simples. Desde que você preste atenção ao que está fazendo, tudo dará certo. No entanto, se você se descuidar, a coisa irá sair completamente do controle. Para compreender isto, vamos ver como o código iria ficar na prática. Ele pode ser visto logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     Factorial();
07.     Factorial();
08.     Factorial();
09.     Factorial();
10.     Factorial();
11. }
12. //+------------------------------------------------------------------+
13. void Factorial(void)
14. {
15.     static uchar counter = 0;
16.     static ulong value = 1;
17. 
18.     Print("Factorial of ", counter, " => ", value);    
19.     counter = counter + 1;
20.     value = value * counter;
21. }
22. //+------------------------------------------------------------------+

Código 04

Observe que a única mudança entre o código 03 e o código 04 é justamente a presença da palavra reservada static nas linhas 15 e 16. Porém somente por conta deste fato, agora o resultado, quando executado este código 04 no terminal do MetaTrader 5 é exatamente o que é visto na figura 01, ou seja, obtivemos o tal esperado sucesso. No entanto, devido a própria natureza estática, estas variáveis declaradas estáticas devem ser tratadas com um certo cuidado e atenção. Isto por que existem regras muito específicas sobre as mesmas. Não que você seja obrigado a fazer certas coisas. Mas sim por que você precisa entender como elas funcionam.

Uma variável estática é em primeira ordem, uma variável que deverá sempre estar dentro de um bloco. Apesar de podermos usar elas em certos tipos de situação, fora de blocos, para fins específicos. Você deve sempre pensar em usar elas dentro de algum tipo de um bloco.

Segundo, salvo em casos muito, mais muito específicos, NUNCA inicialize uma variável estática fora do local de sua declaração. Fazer isto, sem o devido cuidado, poderá fazer com que você venha a perder o controle sobre o seu código. Como aqui estamos trabalhando com algo muito simples e voltado para a didática. Você pode ter uma falsa sensação de controle. Porém não se iluda, achando que você está sempre no controle. A qualquer vacilo que você cometer, pronto. Lá se vão horas ou dias para tentar resolver o problema. Para tornar e deixar isto bem claro, vamos fazer uma pequena mudança no código 04. E veja o que irá acontecer. A mudança pode ser vista no código logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     Factorial();
07.     Factorial();
08.     Factorial();
09.     Factorial();
10.     Factorial();
11. }
12. //+------------------------------------------------------------------+
13. void Factorial(void)
14. {
15.     static uchar counter;
16.     static ulong value = 1;
17. 
18.     counter = 1;
19.     Print("Factorial of ", counter, " => ", value);    
20.     counter = counter + 1;
21.     value = value * counter;
22. }
23. //+------------------------------------------------------------------+

Código 05

Estou colocando os códigos na íntegra para que você consiga acompanhar as mudanças. Assim você conseguirá compreender de maneira mais profunda o que estará ocorrendo. E o que um simples vacilo pode fazer em uma aplicação. Mas observe e compare a mudança que ocorreu aqui. Entre o código 04 e este código 05. Parece algo banal, quase sem nenhum risco ou efeito colateral. Algo que você se quer pensaria que iria causar algum problema ou mesmo mudança nos resultados finais. Porém quando executado, o que era para ser a figura 01, sendo mostrada no terminal do MetaTrader 5. Passa a ser algo completamente diferente e pode ser visto na figura logo na sequência.

Figura 03

Cara que coisa mais maluca. Pelo que eu consigo perceber, o que era para ser um cálculo fatorial, virou um cálculo de potência de dois. Isto sim é algo muito maluco. Mas por que isto ocorreu ?!?! Bem meu caro leitor, existe um pequeno macete para se trabalhar adequadamente com variáveis estáticas. Um programador mais experiente, quando se depara com um código que não está se comportando como esperado. Logo suspeita de alguma falha no uso das variáveis. Se a linguagem permite o uso de tal tipo de variável e o código contém variáveis deste tipo. Você deve primeiro verificar estas variáveis.

Procure verificar se elas estão sendo corretamente inicializadas, e se é esperado uma mudança nos valores da mesma. Estes são os primeiros pontos que você deverá verificar. Como normalmente mudanças de valores em variáveis é algo esperado, caso contrário usaríamos constantes. Você pode verificar se a variável está mudando e se ela não está esquecendo o último valor atribuído a ela. Existem diversas técnicas de debug para isto. Procure estudar como debugar um programa para mais detalhes, pois cada situação exige uma abordagem um pouco diferente.

Mas voltando a questão, do por que o código se comportou de maneira estranha. Sendo que aparentemente não há nada de errado nele. É o primeiro pensamento que se passa na cabeça de qualquer programador. Porém variáveis estáticas SÃO INICIALIZADAS no momento em que são criadas. Se isto não for feito, no momento em que você atribuir um valor a ela, a mesma irá se comportar como uma variável local. Ou seja, é como se ela estivesse sido declarada neste momento. Naturalmente, isto implica que você, dentro de um bloco, deve evitar ao máximo o que é visto na linha 18 do código 05. Fazer isto irá quebrar a variável estática. Fazendo com que ela trabalhe de maneira incorreta. Por isto o código se comportou de maneira estranha. Por que o que era uma variável estática, agora é apenas uma variável comum.

Legal, com isto já temos uma boa base para começar a trabalhar nos próximos pontos.

Tipos de dados

Dentro do assunto que estamos tratando neste momento. Existe uma questão que podemos dar uma rápida passada por ele. Isto a fim de abordar o tema de uma forma inicial. Já que conforme iremos avançando, você irá notar que existe muito mais coisas envolvidas aqui.

O assunto em questão é o tipo de dado ou variável. Diversas linguagens, mas principalmente linguagens baseadas em scripts, que posso citar como exemplos: O JavaScript e Pyhton. São linguagens que não exigem do programador a declaração de tipo do dado a ser armazenado. Ou seja, são do tipo NÃO TIPADAS. Enquanto outras como C / C++, e o próprio MQL5, são linguagens fortemente TIPADAS. Ou seja, elas exigem que o programador diga que tipo de dados é esperado. E o que isto significa na prática ?!?! Bem, na prática, isto significa que uma variável no Python pode receber qualquer tipo de valor. Porém uma mesma variável em MQL5, não poderá receber qualquer valor. Isto em tese, já que existem maneira de tentar contornar este tipo de inconveniente.

De qualquer forma, para quem programa em linguagens tipadas, existe um nível de dificuldade maior em se fazer certas coisas. Já que não é só você declarar uma variável e já poderá colocar qualquer coisa nela. Existem regras e limites para isto. No entanto, linguagens como Python, permitem que uma variável possa receber um texto, ou mesmo um valor qualquer. E a própria linguagem, irá tratar de adequar a variável ao tipo mais adequado. Ou seja, a dificuldade em se programar é muito menor devido a isto. Tornando assim a criação de código, muito mais simples, rápido e sem muita especialização por parte do programador. Diferente do que acontece em uma linguagem tipada. Onde você precisa saber o que cada tipo pode ou não conter.

Neste momento, talvez você esteja pensando em desistir de entender MQL5 e passe a procurar algo mais simples como Python ou JavaScript. Porém, sem fazer pouco caso destas outras linguagens não tipadas. Quando você aprende a lidar com os tipos presentes em uma linguagem, trabalhar em uma onde não existe este controle, se torna algo muito sem graça e as vezes até chato. Já que manipular dados é entender o que cada um representa. Podendo os classificar em tipos e sabendo qual é o limite que cada um tem. Este tipo de conhecimento abre portas para diversas coisas interessantes. Como criptografia ou compactação de dados.

Mas vamos deixar para falar isto em outro momento. Neste presente momento, vamos entender o que seria os tipos e quais as limitações básicas deles.

No MQL5 temos alguns tipos básicos, que podem ser: Inteiros, lógicos, literais, ponto flutuante, enumeradores e strings. Estes são encontrados também em códigos C / C++. Porém além destes que são comuns em muitas linguagens baseadas em C / C++, o MQL5 tem alguns especiais, que são: dados de cor e  dados para data e hora. Apesar de que estes são tipos derivados de outros como iremos ver no futuro. Mas o fato de eles existirem ajuda bastante em diversos momentos.

Entretanto, existem também tipos complexos de dados, tanto em C / C++ quanto no MQL5. Estes tipos são classificados como estruturas e classes. No caso das classes, elas existem apenas no C++. Porém aqui no MQL5, as mesmas são muito mais simples de entender e de trabalhar com elas, do que no C++. Apesar de que em alguns momentos, eu como programador C++, sinto falta de alguns dos recursos de classes presentes no C++, que não existem no MQL5. Mas se não tem, nos adaptamos, para que o trabalho e o objetivo ainda sejam cumpridos.

Legal, está foi a introdução básica sobre o tema. Mas podemos falar um pouco mais, antes de finalizar este artigo. Como por exemplo a questão dos limites de cada um dos tipos básicos. Conhecer e entender estes limites, irão lhe ajudar imensamente na criação dos seus futuros código. Seja ele para qual objetivo você desejar. Vamos começar com uma pequena tabela. Esta pode ser observada logo abaixo.

Tipo	Número de bytes	Menor valor	Maior valor
char	1	-128	127
uchar	1	0	255
bool	1	0 (Falso)	1 (Verdadeiro)
short	2	-32 768	32 767
ushort	2	0	65 535
int	4	- 2 147 483 648	2 147 483 647
uint	4	0	4 294 967 295
color	4	-1	16 777 215
float	4	1.175494351e-38	3.402823466e+38
long	8	-9 223 372 036 854 775 808	9 223 372 036 854 775 807
ulong	8	0	18 446 744 073 709 551 615
datetime	8	0 (01/01/1970 00:00:00)	32 535 244 799 (31/12/3000 23:59:59)
double	8	2.2250738585072014e-308	1.7976931348623158e+308

Tabela de tipos básicos

Esta tabela representa apenas e somente os tipos simples de dados. Aqui não estamos analisando os tipos complexos. Isto será visto em um momento mais oportuno. Porém entender esta tabela com os tipos simples, nos ajuda a escolher o tipo mais adequado ao que iremos necessitar durante os nossos cálculos. Isto por que, cada tipo tem um limite inferior e superior que pode ser representado por ele.

Porém existe algo aqui nesta tabela, que será analisado com mais calma no futuro. Que são os tipos double e float. Isto por que, ambos os tipos tem algumas peculiaridades que precisam ser explicadas a parte e com calma. Isto para que você de fato possa compreender os mesmos de maneira adequada.

Mas vamos analisar brevemente esta tabela. Você pode notar que existe uma similaridade nos nomes. Onde em alguns casos temos a letra u precedendo o nome do tipo. Estilo char e uchar. Onde justamente esta letra u tem um significado especial. Quando o nome do tipo é precedido com esta letra u, significa que o tipo inicia em zero e vai até um máximo qualquer. Já que este u inicial vem da palavra inglesa unsigned, que significa sem sinal. Mas o que sem sinal significa na prática ?!?! Bem meu caro leitor, quando temos um valor sem sinal, significa que ele será interpretado como sendo sempre um valor positivo. E quando temos um valor com sinal, podemos ter um valor negativo, ou positivo. Isto será melhor compreendido quando falarmos sobre operações matemáticas. Mas basicamente, você pode interpretar da seguinte maneira. Se você quer armazenar um valor negativo poderá colocar ele em um tipo que tenha sinal. No entanto, se todos os valores que forem armazenados são positivos, você poderá colocar em um tipo sem sinal. Mas por que estou dizendo: Poderá ?!?! Não seria correto dizer: Deverá ?!?! Na verdade, isto não é obrigatório meu caro leitor. Quando formos falar sobre operações matemáticas, irei explicar isto em mais detalhes. Mas existe somente uma regra aqui: Valores do tipo inteiro, ou seja, que não fazem uso do ponto flutuante, são valores precisos. Valores do tipo ponto flutuante, não são valores exatos. Mesmo que olhando para esta tabela, você imagine que o melhor seria usar dados do tipo double sempre. Justamente por conta que eles cobrem um range considerável. Na prática isto não se aplica de fato. Portanto, saber escolher o tipo adequado é algo primordial para um bom programador.

Porém você deve estar olhando esta tabela e pensando: Mas onde está o tipo string ?!?! Ele não é um tipo básico ?!?! Sim meu caro leitor, o tipo string é um tipo básico. Porém ele é um tipo especial, que se encaixa melhor em outra categoria, que será explicado depois. Por conta disto é que ele não aparece aqui nesta tabela.

Considerações finais

Neste artigo, foi basicamente dedicado em falar sobre variáveis do tipo estática. Fizemos alguns experimentos com as mesmas a fim de demonstrar como você poderia em algum momento tirar proveito delas. É fato, que aqui apenas dedicamos em explicar uma das possíveis aplicações do tipo estático. Já que elas também podem ser utilizadas para outros propósitos também. Porém a grande maioria das vezes, em que você irá se deparar com variáveis do tipo estática. As mesmas estarão sendo utilizadas como foi mostrado aqui. Em um outro artigo iremos falar sobre outras formas de utilizar variáveis estáticas para outros fins. Por hora, o que foi visto e mostrado aqui, já lhe ajudará a entender muitos programas. Assim como também, lhe ajudará a implementar soluções melhores, que não fazem uso massivo de variáveis globais, sem nenhum tipo de critério.

Também demos uma leve olhada no que será o tema do próximo artigo. Que é justamente tipos de dados. Descobrimos que existem diferenças e limites para cada tipo de dado presente no MQL5. Apesar de não ter sido explicado o porquê destes limites. E como podemos criar forma de contornar tais limites a fim de conseguir estender os mesmos para fins mais específicos.

Mas não se preocupe meu caro leitor, iremos ver isto em breve. Por hora me despeço e deixo no anexo, os códigos visto neste artigo. Para que você possa experimentar e tirar suas próprias conclusões a respeito do que foi mostrado neste artigo. Então até breve.