Variáveis Avançadas e Tipos de Dados em MQL5

Introdução

MQL5 é a linguagem de programação do MetaTrader 5, considerada a plataforma de negociação mais popular e muito rica em ferramentas e conceitos que podem ser usados para criar qualquer sistema de negociação, desde o simples até o complexo. Nosso objetivo como desenvolvedores é entender como usar essas ferramentas e conceitos para alcançar nosso objetivo de desenvolvimento.

Já mencionamos o básico sobre variáveis simples e tipos de dados em MQL5 em nosso artigo Aprenda por que e como projetar seu sistema de negociação algorítmica e aprendemos mais sobre como podemos usar MQL5 para codificar software de negociação, variáveis em termos de definição, seus tipos e como podemos usá-las. Também aprendemos sobre tipos de dados simples como inteiro, float, double, string e bool, também mencionamos variáveis de entrada e como elas podem ser usadas para dar ao usuário a vantagem de definir suas preferências no software.

Em outro artigo, Aprenda a lidar com data e hora em MQL5, aprendemos em detalhes sobre o tipo de dado Datetime, porque aprendemos como usar esse tipo de dado importante que nenhum software deixa de usar, especialmente em software de negociação.

Neste artigo, mencionaremos e aprofundaremos para aprender mais sobre variáveis e tipos de dados em MQL5 e como eles podem ser úteis ao criar ou construir software de negociação MQL5. Aprenderemos mais sobre alguns conceitos avançados de variáveis e tipos de dados e os cobriremos através dos seguintes tópicos:

• Constantes: são identificadores cujos valores são imutáveis.
• Arrays: são qualquer tipo de variável com múltiplos valores. 
• Enumerações: são listas de constantes inteiras com valores inteiros.
• Estruturas: são um conjunto de variáveis relacionadas com tipos diferentes.
• Conversão de tipo: é o processo de converter um tipo de valor para outro.
• Variáveis locais: são variáveis declaradas localmente dentro das funções.
• Variáveis globais: são variáveis declaradas globalmente fora das funções.
• Variáveis estáticas: são variáveis locais declaradas que retêm seus valores na memória.
• Variáveis predefinidas: são variáveis predefinidas pelo criador da linguagem de programação.

Tentaremos explicar cada tópico em detalhes para entender como podemos usá-lo e ver o máximo de exemplos possível para aprofundar nossa compreensão e ser capaz de usar todos os conceitos mencionados de forma eficaz. Programação é o tipo de ciência em que a prática é muito importante, então é muito importante tentar e aplicar o que você aprende para entender como pode usar cada conceito como parte do seu código geral para criar um sistema de negociação eficaz.

Constantes

Nesta parte, vamos nos aprofundar no conceito de constantes na programação e no MQL5 para entender por que precisamos usar esse tipo de variável. A variável constante também é chamada de somente leitura ou constante nomeada, não pode ser alterada ou não podemos atribuir um novo valor a ela após a primeira inicialização e, se o código tentar fazer isso, produzirá um erro. O conceito de constante é suportado pela maioria das linguagens de programação e MQL5 também suporta esse conceito, temos dois métodos para definir a constante em nosso software:

• Constantes globais
• O especificador de const

Constantes globais:

Esta constante global pode ser definida usando a diretiva de pré-processador #define no início do nosso software globalmente, especificando o identificador e, depois disso, atribuindo o valor constante. O valor constante pode ser qualquer tipo de dado, como o tipo string, e o seguinte é o que precisamos codificar em nosso software:

#define Identifier_Name constant_value

Como podemos ver no código anterior, temos a diretiva de pré-processador #define que especifica que temos uma declaração constante e podemos ver um exemplo como o seguinte para entender mais sobre este método:

No escopo global, primeiro usamos a diretiva de pré-processador #define para declarar que temos uma constante, o identificador é PLATFORM_NAME e o valor constante do identificador é o tipo de dado string "MetaTrader 5"

#define PLATFORM_NAME "MetaTrader 5"

Na função necessária, podemos dizer que no OnStart() por exemplo, imprimiremos o identificador

void OnStart()
  {
   Print("The trading platform name is: ", PLATFORM_NAME);
  }

Ao compilar e executar o software, podemos encontrar o resultado como uma mensagem na guia expert, conforme a captura de tela a seguir

O valor constante do MetaTrader 5 não pode ser alterado, como mencionamos.

O especificador de const:

De acordo com este método, podemos declarar a constante usando o especificador const antes da variável e seu tipo de dado. Este especificador declara que será uma constante e não pode ser alterada e o seguinte é como podemos fazer isso

const int varName = assignedVal

O seguinte é um exemplo simples de declaração de uma constante por este método

const int val = 1;

Se precisarmos imprimir o valor dessa variável

Print("constant val is: ", val);

Podemos encontrar o resultado conforme o seguinte:

Como mencionamos, se tentássemos atualizar a variável (val) encontraremos que o seguinte erro será produzido porque é uma constante e não pode ser atualizada.

Para ilustrar a diferença entre uma variável normal e uma constante, podemos usar o seguinte exemplo, onde temos dois valores, um é uma constante e o outro é uma variável normal.

   const int val = 1;
   int val2 = 2;
   
   Print("constant val is: ", val);
   Print("val 2 is: ", val2);

O resultado será o mesmo da captura de tela a seguir ao executar este software

Agora, vejamos se tentarmos atualizar val2 com outro valor, que é 4, com este código

val2 = 4;

Se você imprimir esses dois valores novamente, o resultado será o mesmo do exemplo a seguir:

Como podemos ver, o valor de val2 foi atualizado para 4 em vez de 2.

Arrays

Nesta parte, entenderemos um conceito básico em qualquer linguagem de programação, que é o array. O array é uma variável onde podemos armazenar muitos valores de qualquer tipo de dado. Podemos pensar no array como uma lista com índices e valores correspondentes. Quando precisamos acessar um valor específico, podemos fazê-lo por indexação.

A indexação de array começa em zero, então o índice máximo é o mesmo que o resultado de diminuir o tamanho do array em um valor. Se tivermos um array com cinco valores, seus índices serão (0, 1, 2, 3, 4) e o valor máximo, como podemos ver, é 4, que é o resultado de (5-1).

Se precisarmos acessar o valor de um índice específico, nos referimos a ele com seu índice em colchetes [] e isso é o que queremos dizer com acesso por indexação, como mencionamos anteriormente.

Também temos um array estático e um array dinâmico e a diferença entre os dois em termos de tamanho do array é que o array estático tem um tamanho fixo e não pode ser redimensionado, mas o array dinâmico não tem tamanho e pode ser usado se precisarmos redimensionar o array em vez de usar o estático.

Declaração de array estático

Se precisarmos declarar um novo array estático, podemos fazê-lo usando o exemplo a seguir

int newArray[5];

newArray[0] = 1;
newArray[1] = 2;
newArray[2] = 3;
newArray[3] = 4;
newArray[4] = 5;

Print("newArray - Index 0 - Value: ", newArray[0]);
Print("newArray - Index 1 - Value: ", newArray[1]);
Print("newArray - Index 2 - Value: ", newArray[2]);
Print("newArray - Index 3 - Value: ", newArray[3]);
Print("newArray - Index 4 - Value: ", newArray[4]);

Depois de executar este software, podemos ver o mesmo resultado que na captura de tela a seguir

Podemos obter o mesmo resultado declarando o array usando o código abreviado a seguir para mais eficiência, atribuindo valores ao array dentro dos colchetes {} e separando-os com uma vírgula (,).

   int newArray[5] = {1, 2, 3, 4, 5};

   Print("newArray - Index 0 - Value: ", newArray[0]);
   Print("newArray - Index 1 - Value: ", newArray[1]);
   Print("newArray - Index 2 - Value: ", newArray[2]);
   Print("newArray - Index 3 - Value: ", newArray[3]);
   Print("newArray - Index 4 - Value: ", newArray[4]);

 Se executarmos o código anterior, obteremos o mesmo resultado em mensagens impressas, como mencionamos.

Declaração de array dinâmico

Como mencionamos antes, o array dinâmico é o array sem um tamanho fixo e pode ser redimensionado. O que precisamos saber aqui é que este tipo de array é usado quando codificamos através do MQL5 para armazenar dados como preço e valor de indicador, porque esses dados são dinâmicos, então este tipo será mais adequado.

Se precisarmos declarar um novo array dinâmico, podemos fazer o mesmo que vemos no código a seguir

   double myDynArray[];
   ArrayResize(myDynArray,3);

   myDynArray[0] = 1.5;
   myDynArray[1] = 2.5;
   myDynArray[2] = 3.5;
   
   Print("Dynamic Array 0: ",myDynArray[0]);
   Print("Dynamic Array 1: ",myDynArray[1]);
   Print("Dynamic Array 2: ",myDynArray[2]);

Como podemos ver no código anterior, declaramos o array com um colchete vazio, depois usamos a função ArrayResize para redimensionar o array, e podemos ver o resultado ao executar o software, conforme mostrado na captura de tela a seguir

Como podemos ver na captura de tela anterior, temos três mensagens impressas para cada índice e o valor correspondente. Agora identificamos os arrays unidimensionais, mas também podemos usar arrays multidimensionais, como dois, três ou quatro, mas os mais comuns que usamos frequentemente são dois ou três.

Arrays Multidimensionais

Arrays multidimensionais podem ser considerados como arrays aninhados ou arrays dentro de arrays. Como exemplo, podemos dizer que temos dois arrays e cada um tem 2 elementos, podemos ver como podemos codificar esse tipo de array da seguinte forma:

Declaração de arrays bidimensionais com dois elementos

double newMultiArray[2][2];

Atribuindo valores ou elementos ao primeiro array com índice 0

newMultiArray[0][0] = 1.5;
newMultiArray[0][1] = 2.5;

 tribuindo valores ou elementos ao segundo array com índice 1

newMultiArray[1][0] = 3.5;
newMultiArray[1][1] = 4.5;

Imprimindo os valores dos dois arrays e seus elementos ou valores

   Print("Array1 - Index 0 - Value: ", newMultiArray[0][0]);
   Print("Array1 - Index 1 - Value: ", newMultiArray[0][1]);
   Print("Array2 - Index 0 - Value: ", newMultiArray[1][0]);
   Print("Array2 - Index 1 - Value: ", newMultiArray[1][1]);

Depois de executar este software, podemos ver a mesma saída que a captura de tela a seguir

Como podemos ver na captura de tela anterior, temos o Array 1 com dois valores 1.5 e 2.5, também temos o Array 2 com dois valores 3.5 e 4.5.

Também é bom mencionar aqui que quando declaramos arrays multidimensionais, podemos deixar apenas a primeira dimensão vazia, assim como no exemplo a seguir

double newMultiArray[][2];

Depois podemos passá-lo usando uma variável, como a seguir

int array1 = 2;
ArrayResize(newMultiArray, array1);

Depois de compilar e executar este software, encontraremos o mesmo resultado que encontramos antes.

Enumerações

Nesta parte, identificaremos enumerações. Podemos pensar em enumerações como conjuntos de dados ou listas de constantes ou itens que podem ser usados para descrever conceitos relacionados e temos enumerações incorporadas e enumerações personalizadas. Enumerações incorporadas são predefinidas no MQL5 e podemos chamá-las e usá-las em nosso programa, mas enumerações personalizadas são enumerações personalizadas de acordo com nossas necessidades.

Enumeração incorporada, podemos encontrá-las listadas na documentação ou referência do MQL5, como por exemplo ENUM_DAY_OF_WEEK. Mas se olharmos para as enumerações personalizadas, podemos ver que podemos definir o que precisamos para usá-las mais tarde em nosso software criado.

O seguinte é como podemos usar essas enums em nosso software. Primeiro, usamos a palavra-chave enum para definir uma enumeração, o nome do tipo de enumeração e uma lista de valores de tipo de dados relacionados separados por vírgulas.

enum name of enumerable type 
  { 
   value 1,
   value 2,
   value 3
  };

Vamos ver um exemplo para criar nossa enum workingDays chamada, esta workingDays será um tipo que eu declararei variáveis para ela mais tarde

   enum workingDays
     {
      Monday,
      Tuesday,
      Wednesday,
      Thursday,
      Friday,
     };

Agora precisamos declarar uma nova variável relacionada do tipo workingDays, atribuir o valor de hoje entre os definidos na lista e imprimir essa variável

     workingDays toDay;
     toDay = Wednesday;
     
     Print(toDay);

Podemos encontrar a mensagem de (2) para quarta-feira como um dia útil da lista começando do 0 para segunda-feira até 4 para sexta-feira, conforme a captura de tela a seguir.

Também podemos determinar outro número inicial a ser atribuído em vez de (0) atribuindo o número que precisamos iniciar ao valor, por exemplo, especificando que Monday = 1.

Estruturas

Podemos achar que precisamos declarar vários tipos de dados diferentes para variáveis relacionadas, caso em que a estrutura fará isso de forma eficaz, porque pode ser usada para fazer o mesmo que encontraremos nesta parte. Os membros desta estrutura podem ser de qualquer tipo de dado, ao contrário de uma enumeração, porque seus membros só podem ser do mesmo tipo. São iguais às enumerações, existem estruturas predefinidas no MQL5, como MqlTick, por exemplo, e podemos criar as nossas próprias.

Digamos que precisamos criar uma estrutura para tradeInfo, podemos ver que temos o símbolo, preço, stop loss, take profit e tempo de negociação como membros e eles têm tipos de dados diferentes, porque o símbolo é uma string e preço, stop loss e take profit são valores duplos. Então, neste caso, precisamos usar estruturas para fazer a mesma tarefa, como abaixo:

Usaremos a palavra-chave struct para declarar nossa própria estrutura.

   struct tradeInfo
     {
      string         symbol;
      double         price;
      double         stopLoss;
      double         takeProfit;
     };

Podemos então declarar um novo objeto de negociação do tipo tradeInfo e atribuir valores aos membros dessa estrutura acessando-os usando (.) após o nome do objeto, da seguinte forma

   tradeInfo trade;

   trade.symbol = "EURUSD";
   trade.price = 1.07550;
   trade.stopLoss = 1.07500;
   trade.takeProfit = 1.07700;

Podemos imprimir membros com seus valores como a seguir para ver nosso trabalho, como a seguir

   Print("Symbol Trade Info: ", trade.symbol);
   Print("Price Trade Info: ", trade.price);
   Print("SL Trade Info: ", trade.stopLoss);
   Print("TP Trade Info: ", trade.takeProfit);

Podemos encontrar a saída da mensagem impressa da mesma forma que na captura de tela a seguir

Como podemos ver na captura de tela anterior, nossos valores atribuídos são os mesmos que precisamos, então podemos brincar com eles para alcançar nossos objetivos no mesmo contexto.

Conversão de tipo

Nesta seção, entenderemos o conceito de conversão de tipo e o que ele significa. Quando precisamos converter o valor de uma variável de um tipo de dado para outro, podemos chamar esse processo de conversão de tipo, mas esse processo pode produzir resultados inesperados.

Como isso acontece? Quando convertimos ou copiamos um valor com números de uma variável para outra, podemos enfrentar a perda de dados quando esse processo acontece entre tipos.

Os seguintes são exemplos onde nenhum dado é perdido ou algum dado é perdido:

Copiamos um valor inteiro para um valor longo, este caso não produzirá esse tipo de perda de dados porque a conversão é feita de variáveis menores para maiores, quando copiamos um inteiro para um double, também estamos copiando o número inteiro e o valor após o ponto decimal é zero, então não há dados para perder. Se copiarmos um valor double para uma variável inteira, que é o caso oposto, o valor após o decimal será perdido ou truncado.

Vamos ver exemplos através do código para facilitar a compreensão. Primeiro, veremos o caso sem problemas:

   int price = 3 - 1;
   double newPrice = price + 1;
   
   Print ("The price is ", newPrice);

Como podemos ver, o tipo da variável (price) é int, depois o convertimos para uma variável double e depois o imprimimos. Supõe-se que não haverá problema ou perda de dados porque estamos convertendo de um tipo menor para um maior. O seguinte é o resultado da mensagem impressa

Mas quando fazemos o contrário, veremos algo diferente, como a seguir

   double price = 3.50 - 1;
   int newPrice = price + 1;
   
   Print ("The price is ", newPrice);

Como podemos ver, o tipo é double e o valor é 3.50 para a variável price e quando convertemos para uma nova variável int (newPrice), então a imprimimos. Portanto, perderemos os dados após o ponto decimal, que é o valor de (.50) e o resultado será (3), que é o mesmo da mensagem impressa a seguir

É muito importante mencionar aqui que o compilador nos avisará se convertermos um valor de um tipo maior em uma variável de um tipo menor, para que possamos decidir se ignoramos esta mensagem ou não, dependendo de nosso objetivo ou da sensibilidade dos dados perdidos. Abaixo está um exemplo deste aviso:

Também podemos escolher ignorar o aviso se não for prejudicial, ou podemos arredondá-lo adicionando (int) na frente da variável double para exibir o aviso do compilador.

Variáveis locais

Nesta parte, veremos um novo conceito, que é a variável local. Vamos considerar que temos escopos em nosso software: global e local. O escopo global é aquele que podemos acessar em qualquer lugar do nosso software e veremos o conceito de global no próximo tópico em termos de variáveis, mas o local só pode ser acessível no mesmo escopo em que é declarado.

Para maior esclarecimento, se tivermos uma função e dentro dessa função tivermos variáveis que são declaradas apenas no nível da função, essas variáveis são consideradas variáveis locais. Então elas podem ser acessíveis quando a função está sendo executada, depois não serão acessíveis após sair da função.

Vamos pegar um exemplo para tornar isso mais claro:

void myFunc()
{
   int var = 5;
   Print(var);
}

Como podemos ver no código anterior, temos a função myFunc e esta função pode ser chamada em qualquer lugar. Quando chamamos esta função, podemos encontrar uma variável local chamada var e essa variável pode ser executada apenas dentro da função, mas após sair da função, ela não pode ser acessível.

Então, quando chamamos esta função, podemos encontrar a saída sendo 5, que é a mesma da seguinte

Se tentarmos acessar a variável var, que é a local, de fora da função, o compilador produzirá um erro de (identificador não declarado), como a seguir:

O mesmo se aplica se tivermos níveis ou escopos aninhados dentro da função, cada variável declarada só será acessível em seu escopo.

Vamos pegar um exemplo sobre este caso também:

void myFunc()
  {
   int var = 5;
   if(var == 5)
     {
      int newVar = 6 ;
      Print(newVar);
     }

  }

Como podemos ver no exemplo anterior, temos um if aninhado para comparar o valor de var com 5 e se for verdadeiro, declararemos newVar com um valor de 6 e o imprimiremos. A saída será 6 porque a condição é verdadeira, como segue

Esta newVar é uma nova variável local dentro do escopo do operador if e não pode ser acessível fora dele, assim como qualquer outro escopo local e se tentarmos, o compilador produzirá o erro de variável não declarada. É importante saber que qualquer declaração para uma variável com o mesmo nome da variável local, substituirá a anterior e será digitada em um escopo mais alto.

Então o conceito é muito simples, qualquer variável local será acessível em seu nível ou escopo dentro da função. Mas o que fazemos se precisarmos acessar uma variável em qualquer lugar do nosso software? Aqui a variável global entra em cena, como veremos no próximo tópico de variáveis globais.

Variáveis globais

No tópico anterior sobre variáveis locais, mencionamos variáveis globais, que são variáveis declaradas globalmente, o que significa que podemos acessá-las de qualquer lugar em nosso software, ao contrário das variáveis locais. Então, quando precisamos declarar variáveis globais, teremos cuidado para declará-las globalmente ou no escopo global do software, fora de qualquer função, para que possamos usá-las ou chamá-las em qualquer lugar do software. Esses tipos de variáveis podem ser usados quando precisamos declarar uma variável que será usada muitas vezes por muitas funções.

As variáveis globais são definidas no início ou no topo do software, após as variáveis de entrada. Ao contrário das variáveis locais, se tentarmos declarar variáveis globais dentro do bloco, isso produzirá um erro de compilação de "A declaração da variável oculta a declaração global", como a seguir:

Podemos atualizar variáveis globais em qualquer ponto do software, como no exemplo a seguir, que mostra como podemos declarar e atualizar variáveis globais:

int stopLoss = 100;

void OnStart()
  {
   Print("1st Value: ", stopLoss);
   addToSL();
  }

void addToSL()
  {
   stopLoss = stopLoss + 50;
   Print("Updated Value: ", stopLoss);
  }

Como podemos ver no bloco de código anterior, declaramos a variável stopLoss globalmente no topo do software, imprimimos o valor atribuído, chamamos a função addToSL() que adicionou 50 ao primeiro valor atribuído e depois imprimimos o valor atualizado. Depois de compilar e executar este software, podemos encontrar mensagens impressas como a seguir:

Como podemos ver, o primeiro valor inicial da variável é 100 e, ao atualizá-lo adicionando 50 na função addToSL(), tornou-se 150.

Variáveis estáticas

Nesta parte, identificaremos outro tipo de variável, que é a variável estática. Variáveis estáticas são variáveis locais, mas mantêm seus valores na memória, mesmo se o software tiver saído do escopo delas e podem ser declaradas no bloco de funções ou variáveis locais.

Podemos fazer isso usando a palavra-chave static antes do nome da variável e atribuindo seu valor, e podemos ver o exemplo a seguir para maior esclarecimento

void staticFunc()
{
   static int statVar = 5;
   statVar ++;
   Print(statVar);
}

Em seguida, chamaremos a função staticFunc()

staticFunc();

Aqui, a variável manterá seu valor (5) na memória e toda vez que chamarmos a função, a saída será 6, que é (5+1). A seguir está uma captura de tela da saída:

Como podemos ver, a mensagem impressa do valor 6 na guia expert.

Variáveis predefinidas

No campo da programação, podemos nos ver precisando escrever muitas linhas repetidamente para fazer algo comumente usado. Portanto, em muitas linguagens de programação, existem variáveis ou até mesmo funções que são predefinidas, o que significa que elas são codificadas e podemos usá-las facilmente sem a necessidade de reescrever todo o código novamente. Aqui, o papel das variáveis predefinidas entra em jogo. Tudo o que precisamos fazer é lembrar ou saber qual é a palavra-chave para fazer algo e usá-la.

O MQL5 tem muitas variáveis predefinidas e podemos acessar seus valores da mesma forma que os exemplos abaixo:

• _Symbol: refere-se ao símbolo atual no gráfico.
• _Point: refere-se ao valor do ponto do símbolo atual, é 0.00001 em cinco dígitos do símbolo atual e 0.001 em três dígitos do símbolo atual.
• _Period: refere-se ao período ou intervalo de tempo atual do símbolo.
• _Digits: refere-se ao número de dígitos após o ponto decimal do símbolo atual. Se tivermos um símbolo de cinco dígitos, isso significa que o número após o ponto decimal é 5, e um símbolo de três dígitos significa que o símbolo tem três números após o ponto decimal.
• _LastError: refere-se ao valor do último erro.
• RandomSeed: refere-se ao estado atual do gerador de números inteiros pseudo-aleatórios.
• _AppliedTo: permite saber o tipo de dado usado para calcular o indicador.

Essas e outras variáveis predefinidas podem ser encontradas na documentação na seção Variáveis Predefinidas.

Conclusão

Este artigo explora as complexidades do MQL5, focando em conceitos essenciais de programação, como tipos de dados, variáveis e outros elementos chave cruciais para o desenvolvimento de software avançado. Dominar o MQL5 requer compreensão de aspectos básicos e complexos, com a prática sendo fundamental para se tornar proficiente. Este guia visa ajudar em sua jornada de aprendizado no MQL5 para desenvolvimento de plataformas de negociação. Para mais insights sobre programação ou criação de sistemas de negociação com indicadores técnicos populares, como Médias Móveis, RSI e outros, confira minhas publicações para artigos detalhados e dicas de desenvolvimento de estratégias.