Introdução ao MQL5 (Parte 4): Estruturas, classes e funções de tempo

Introdução

Bem-vindo à quarta parte de nossa série, dedicada aos fundamentos do MQL5. Desta vez, vamos conhecer estruturas, classes e funções de tempo, tentando tornar conceitos complexos mais acessíveis. O objetivo permanece o mesmo: criar um espaço inclusivo onde a linguagem MQL5 seja acessível para todos. Lembro mais uma vez que todas as suas perguntas são bem-vindas — perguntem para que nenhum detalhe fique no ar. Vamos juntos nos esforçar para que o aprendizado do MQL5 seja não apenas útil, mas também agradável.

Eu entendo que a programação pode ser cansativa, especialmente para iniciantes. É por isso que nestes artigos tentamos detalhar ao máximo coisas complexas para que sejam claras para todos. Mas se algo ainda não ficou claro, façam perguntas. A curiosidade abre o caminho para o conhecimento. Estamos entrando em um novo capítulo no estudo do trading algorítmico. Aqui apresentamos não apenas material teórico, mas também exemplos práticos de código com explicações detalhadas. Espero que seja uma jornada agradável rumo ao mundo do conhecimento. Bons estudos e lembre-se: a curiosidade é o melhor companheiro do progresso.

Neste artigo, vamos abordar os seguintes tópicos:

• Estruturas
  
• Classes
  
• Funções de tempo no MQL5

Caros leitores, antes de passar para o estudo do material principal desta quarta parte, eu, como de costume, apresentarei um breve vídeo para refrescar os conhecimentos sobre os conceitos expostos na terceira parte. Este vídeo serve como um breve resumo. Além disso, ele ajudará a refrescar os conhecimentos e se preparar para o estudo do novo material. E se você precisar revisar os fundamentos ou voltar e estudar mais detalhadamente os detalhes perdidos, este vídeo é uma mão na roda. Em seguida, passaremos ao estudo do novo material, que também pertence à categoria de fundamentos.

1. Estruturas

O que são estruturas?

Na programação, uma estrutura é um tipo de dado composto que permite agrupar diferentes tipos de dados sob um único nome. Elas permitem organizar fragmentos de informação logicamente relacionados e gerenciá-los convenientemente. A estrutura pode incluir vários tipos de dados, como números inteiros, números de ponto flutuante e caracteres. O objetivo principal da estrutura é melhorar a legibilidade do código e sua reutilização, bem como representar objetos com múltiplos atributos.

No MQL5, a estrutura serve ao mesmo propósito. É um tipo de dado definido pelo usuário que permite criar um contêiner para armazenar elementos de dados relacionados. As estruturas no MQL5 são comumente usadas para representar objetos do mundo real como algoritmos de trading, instrumentos financeiros ou em quaisquer cenários onde vários atributos precisam estar associados a um único objeto. A sintaxe para declarar estruturas no MQL5 é semelhante à de outras linguagens. As estruturas representam uma maneira universal de organizar dados de forma eficiente e acessá-los em scripts de trading e EAs.

Analogia

Imagine uma estrutura como uma mochila. Nessa mochila, você pode colocar diferentes coisas: brinquedos, lanches e até um pequeno mapa. Cada item na mochila é uma informação distinta. Por exemplo, o brinquedo é um tipo de brinquedo, os lanches têm sabor, e o mapa mostra a direção. 

Essa mochila pode ser vista como uma estrutura na programação. A estrutura contém diferentes tipos de informações (brinquedos, lanches e mapas) da mesma forma que uma estrutura armazena diferentes fragmentos de dados em um programa. Se você precisa saber sobre um brinquedo, você olha dentro da mochila e encontra o brinquedo. No programa, você usa a estrutura para encontrar determinados fragmentos de informação. Assim, a estrutura ajuda a organizar e transportar diferentes coisas, facilitando a localização do que você precisa.

1.1. Como declarar estruturas

Declarar uma estrutura no MQL5 é semelhante a definir uma estrutura ao criar, digamos, um formulário para preencher. Você especifica os tipos e os nomes dos vários fragmentos de informação que deseja incluir.

struct Person
 {
    string name;
    int age;
    string address;
};

Explicação:

“struct Person”:

• Esta linha inicia a declaração de uma estrutura chamada Person. Na estrutura, este é um tipo de dado definido pelo usuário, que permite agrupar vários tipos de variáveis sob um único nome.

“string name;”:

• Dentro da estrutura, três campos (variáveis) são declarados. O primeiro é name e tem o tipo string. Este campo é destinado a armazenar o nome da "pessoa" (person).
  

“int age;”:

• O segundo campo é age, e tem o tipo int. Este campo é destinado a armazenar a idade da pessoa.

“string address;”:

• O terceiro campo é address, também do tipo string. Este campo é destinado a armazenar o endereço da pessoa.

Dessa forma, temos um contêiner ou formulário especial onde podemos organizar ordenadamente as informações sobre uma pessoa. Essa estrutura Person é semelhante a um formulário com campos específicos (name - nome, age - idade e address - endereço), onde você pode preencher os dados de cada pessoa. Com essa estrutura, você pode criar instâncias para diferentes pessoas, e cada instância conterá informações sobre uma pessoa específica.

1.2. Uso

Depois de declarar a estrutura, você pode usá-la. A própria declaração da estrutura serve como um modelo para criar instâncias personalizadas ou objetos. Essas instâncias armazenarão dados específicos para cada pessoa.

void OnStart()
  {

   struct Person
     {
      string         name;
      int            age;
      string         address;
     };

// Creating variables of type Person
   Person person1, person2;

// Filling in details for person1
   person1.name = "Israel";
   person1.age = 25;
   person1.address = "123 Main St";

// Filling in details for person2
   person2.name = "Bob";
   person2.age = 30;
   person2.address = "456 Oak St";

// Now you can use person1 and person2 with their specific details
   Print("Details of Person 1: ", person1.name, ", ", person1.age, ", ", person1.address);
   Print("Details of Person 2: ", person2.name, ", ", person2.age, ", ", person2.address);

  }

Explicação:

“void OnStart()”:

• Este é o ponto de partida para a execução do script. Qualquer código nesta função será executado ao iniciar o script ou quando você anexá-lo ao gráfico.
  

“Person person1, person2;”:

• Declaração de duas variáveis person1 e person2 do tipo Person. Essas variáveis atuam como contêineres para armazenar informações sobre pessoas.

“person1.name = "Israel";”:

• Atribuímos o valor Israel ao elemento name em person1.
  

“person1.age = 25;”:

• Atribuímos o valor "25" ao elemento age em person1.
  

“person1.address = "123 Main St";”:

• Atribuímos o valor "123 Main St" ao elemento address em person1.
  

“person2.name = "Bob";” to “person2.address = "456 Oak St";”:

• Da mesma forma, atribuímos os valores correspondentes à variável person2.
  

“Print("Details of Person 1: ", person1.name, ", ", person1.age, ", ", person1.address);”:

• Imprimimos os detalhes de person1 usando a função Print.
  

“Print("Details of Person 2: ", person2.name, ", ", person2.age, ", ", person2.address);”:

• Imprimimos os detalhes de person2 usando a função Print.
  

Analogia:

Imagine que você está criando cartões de informações personalizados para pessoas específicas. Esses cartões possuem campos separados para o nome, idade e endereço de cada pessoa. O processo cuidadosamente elaborado garante que cada cartão armazene informações únicas sobre a pessoa para a qual foi criado.

Criando cartões personalizados:

• Na oficina, você coloca duas fichas em branco na mesa de trabalho e as nomeia como person1 e person2. Os cartões são projetados para armazenar diferentes detalhes de pessoas distintas.

Preenchendo os dados no cartão person1:

• No primeiro cartão person1, no campo nome "Name", escrevemos o nome "Israel". Em seguida, na seção de idade "Age", escrevemos a idade 25. Na seção de endereço "Address", escrevemos o endereço da pessoa "123 Main St".

Agora preenchendo o segundo cartão person2:

• Para criar o segundo cartão person2, repetimos o mesmo processo. Desta vez, preenchendo os seguintes dados: nome "Bob", idade "30", endereço "456 Oak St".

Trabalhando com cartões personalizados:

• Pegamos o primeiro cartão person1 e lemos seu conteúdo: "Aqui estão os dados da primeira pessoa — seu nome é Israel, ele tem 25 anos e mora no endereço Main St, 123". Em seguida, lemos o segundo cartão com os detalhes da segunda pessoa.

Neste exemplo, a estrutura Person serve como um modelo que define a existência de seções nos cartões. As variáveis person1 e person2 contêm dados para cada pessoa específica. E para acessar um conjunto específico de dados para cada pessoa, basta pegar o cartão correspondente.

Nota: compreender conceitos como arrays e estruturas pode parecer um pouco confuso no início. Um dos equívocos comuns entre iniciantes é a confusão entre arrays e estruturas devido à sua semelhança aparente. Ambos envolvem a organização de dados, mas são diferentes. Arrays são listas organizadas onde fragmentos de informações semelhantes (tipos de dados semelhantes) são dispostos em ordem sequencial e acessíveis por indexação. Estruturas são mais como contêineres, onde diferentes tipos de informações (tipos de dados variados) podem ser combinados para uma entidade específica.

Ou seja, arrays são coleções de elementos iguais, enquanto estruturas permitem criar tipos de dados complexos que contêm diferentes fragmentos de informação. Mesmo que isso pareça um pouco complicado agora, com o tempo você aprenderá a entender todas essas sutilezas.

2. Classes

O que são classes?

No MQL5, classes podem ser comparadas a modelos que ajudam a criar objetos. Objetos, nesse contexto, são instâncias específicas ou implementações de uma classe. Uma classe é um conjunto de instruções para criar diversos objetos, e cada objeto é um elemento único criado com base nessas instruções.

Imagine que você tem uma classe "Frutas" com instruções para criar diferentes frutas, como maçãs, bananas e laranjas. Os objetos serão maçãs, bananas e laranjas reais, criados com base nessas instruções. Cada objeto-fruta possui atributos específicos (por exemplo, cor e sabor) e pode realizar ações (como ser comido). Assim, no MQL5, classes definem regras, e os objetos são as coisas materiais que você cria de acordo com essas regras.

Analogia

Imagine que você está brincando com um conjunto de construção e tem um conjunto especial de instruções para construir uma nave espacial legal. Esse conjunto de instruções é como uma classe. Ele diz quais cores usar, como empilhar os blocos e até mesmo como fazer a nave espacial voar (como um modelo de classe na programação). Toda vez que você constrói uma nave espacial seguindo essas instruções, essa nave espacial se torna um objeto da classe. Cada nave espacial que você constrói pode ter suas próprias cores e características, mas todas seguem as mesmas instruções.

Na programação de computadores, uma classe também é um conjunto de instruções especiais para criar algo. Ela ajuda os programadores a criar coisas (chamamos essas coisas de objetos) com funções e ações específicas. É uma maneira de organizar e planejar certas etapas, facilitando a criação de muitas coisas semelhantes. Assim, não é necessário começar do zero cada vez. Com esses conjuntos de instruções, você pode criar uma variedade de itens diferentes.

Imagine que você tem uma fábrica que fabrica diferentes tipos de biscoitos. Você tem uma receita - isso é a classe. Ela define quais ingredientes devem estar em cada biscoito e como assá-los.

2.1. Como declarar uma classe

No MQL5, a sintaxe para declarar classes inclui o uso da palavra-chave class, seguida pelo nome da classe e um bloco de código contendo os membros da classe.

Exemplo:

void OnStart()
  {

   class Person
     {
   public:
      // Attributes (data members)
      string         name;
      int            age;

      // Methods (member functions)
      void           displayInfo()
        {
         Print("Name: ", name);
         Print("Age: ", age);
        }
     };

// Creating an object of the Person class
   Person person1;

// Initializing attributes of the object
   person1.name = "John";
   person1.age = 25;

// Calling the displayInfo method to print information
   person1.displayInfo();

  }

Explicação:

Declaração de classe:

class Person {

• Nesta linha, é declarada uma classe chamada Person. A palavra-chave class é seguida pelo nome da classe, e a chave de abertura “{” indica o início da definição da classe.

Área pública:

public:

• Nesta linha, é declarado o especificador de acesso public, indicando que os membros seguintes da classe (atributos e métodos) são acessíveis fora da classe.
  

Atributos (membros de dados):

string name;
int age;

• Nessas linhas, são declarados dois atributos (membros de dados) dentro da classe: um atributo de string chamado name e um atributo inteiro chamado age.
  

Método (função membro):

void displayInfo() 
{
    Print("Name: ", name);
    Print("Age: ", age);
}

• Aqui é definido um método (função membro) chamado displayInfo dentro da classe. Ele imprime os valores dos atributos name e age usando a função Print.
  

Chave de fechamento:

};

• A chave de fechamento “}” marca o final da definição da classe.
  

Uso na função OnStart:

void OnStart() {

• A função OnStart é uma função especial no MQL5 que é executada ao iniciar o script ou o expert.
  

Criação de objeto:

Person person1;

• Esta linha cria um objeto chamado person1 do tipo Person. Assim, é criado um exemplo específico da classe.
  

Definição de atributos:

person1.name = "John";
person1.age = 25;

• Aqui, são atribuídos valores aos atributos name e age do objeto person1.
  

Chamada de método:

person1.displayInfo();

• Esta linha chama o método displayInfo para o objeto person1, que exibe as informações armazenadas nos atributos.
  

Classes e estruturas são semelhantes, mas têm propósitos diferentes. Ambos são usados para definir tipos de dados personalizados e agrupar dados relacionados. A diferença principal está na funcionalidade.

Estruturas são mais simples e servem principalmente como contêineres de dados, sem incluir métodos ou funções. Elas podem ser comparadas a unidades organizadas de armazenamento que agrupam vários elementos de dados para fácil acesso. Classes, na programação orientada a objetos, abrangem não apenas dados, mas também comportamentos através de métodos. Classes são conjuntos de ferramentas versáteis que não apenas contêm informações, mas também fornecem meios para executar ações ou funções. Assim, enquanto ambas, classes e estruturas, organizam dados, classes oferecem um nível adicional de funcionalidade através de métodos.

É completamente normal que a diferença entre classes e estruturas não seja totalmente clara no início. No próximo artigo, apresentarei um vídeo que visualiza esses conceitos para facilitar o entendimento. Portanto, se isso parece um pouco confuso agora, aguarde o próximo artigo. Gradualmente, passo a passo, aprenderemos juntos todos os fundamentos da programação.

3. Funções de tempo no MQL5

Tempo

No contexto da programação e do trading, "tempo" refere-se ao fluxo contínuo de horas, minutos e segundos. Este é um aspecto fundamental do trading algorítmico, pois os mercados financeiros operam em períodos específicos, e os traders precisam sincronizar suas estratégias com esses elementos temporais.

Funções

Na programação, uma função é um bloco autônomo de código projetado para realizar uma tarefa ou operação específica. As funções ajudam a organizar o código, tornando-o mais modular e fácil de entender. Elas recebem dados de entrada, processam esses dados e fornecem uma saída.

O que são funções de tempo?

Funções de tempo na programação, especialmente no MQL5, são ferramentas que permitem aos desenvolvedores e traders trabalhar com dados temporais e utilizá-los em seus algoritmos. Essas funções permitem obter a hora atual do servidor, converter valores de tempo e realizar várias operações relacionadas a carimbos de tempo. No contexto do trading algorítmico, funções de tempo são usadas para sincronizar estratégias de negociação com períodos de tempo específicos, definir horários exatos de execução e criar condições para sinais de negociação baseados em tempo. Elas permitem trabalhar com os aspectos temporais dos mercados financeiros e usá-los em estratégias de trading.

Analogia

Imagine que você tem um relógio que lhe diz quando fazer certas coisas, como brincar, comer ou dormir. No mundo dos programas de computador, funções de tempo são como relógios. Elas ajudam o computador a rastrear o tempo e decidir quando realizar certas tarefas.

Se você está escrevendo um programa para trading, pode usar funções de tempo para dizer: “Se for de manhã, aplique esta estratégia de trading, e se for de noite, faça algo diferente”. Funções de tempo são como instruções sobre o que fazer em diferentes momentos.

Antes de passar para um estudo mais amplo das funções de tempo no MQL5, vamos detalhar a principal — datetime.

3.1. datetime

No MQL5, datetime é um tipo especial de dado usado para representar data e hora. É um relógio digital que pode rastrear a data e a hora atuais no mundo do trading. Este tipo de dado permite que traders e algoritmos determinem o momento de eventos, analisem e implementem estratégias baseadas em condições temporais específicas.

3.1.1. Como declarar uma variável datetime

Então, uma variável datetime armazena data e hora. Quando você declara uma variável datetime, pode definir um momento específico no tempo.

Exemplo:

void OnStart()
  {

// Declaration of datetime variable
   datetime magicalClock;

// Assigning a special date and time to our magical clock
   magicalClock = D'2024.01.15 12:30:00';

// Let's tell the computer to show us the date and time inside our
   Comment(magicalClock);

  }

Explicação:

“datetime magicalClock;”:

• Aqui, declaramos uma variável chamada magicalClock com o tipo de dado datetime. Esta variável armazenará data e hora.

“magicalClock = D'2024.01.15 12:30:00';”:

• Nesta linha, atribuímos uma data e hora específicas (15 de janeiro de 2024, 12:30:00) à variável magicalClock, usando o formato “D'YYYY.MM.DD HH:MI:SS'”.
  
• “D'” indica que estamos atribuindo uma constante de data e hora.
  
• “2024” é o ano.
  
• “01” é o mês.
  
• “15” é o dia.
  
• “12” é a hora.
  
• “30” são os minutos.
  
• “00” são os segundos.
  

“Comment(magicalClock);”:

• Aqui, usamos a função Comment para exibir o conteúdo do relógio (magicalClock). O computador mostrará a data e hora salvas na variável datetime.

Este trecho de código demonstra a declaração, atribuição e exibição de uma variável datetime no MQL5.

3.2. Funções de tempo principais

3.2.1. TimeCurrent

No contexto do trading algorítmico, a função TimeCurrent() no MQL5 representa a hora atual do servidor. Esta função retorna um valor de variável datetime, que essencialmente representa a marcação temporal atual no servidor onde as operações de trading estão sendo executadas.

Qual a importância desta função? Suponha que você use uma estratégia de trading que envolva ações específicas dependendo da hora do dia. Por exemplo, pode haver ações diferentes na abertura e fechamento do mercado ou em horários de alta volatilidade. Usando TimeCurrent(), você pode programaticamente obter acesso ao horário atual e adaptar suas decisões de trading de acordo. Com a sincronização dos relógios com a hora do servidor, seu algoritmo pode se adaptar dinamicamente a diferentes condições de mercado ao longo do dia.

Na prática, você pode usar TimeCurrent() para criar condições nos algoritmos de negociação, dependendo do tempo. Por exemplo, você pode permitir abrir negociações apenas em determinadas horas ou ajustar as estratégias de gerenciamento de riscos dependendo da hora do dia. Dessa forma, você pode garantir a sincronização dos algoritmos com a situação em constante mudança nos mercados financeiros.

Analogia

Vamos imaginar que o tempo na programação é como um relógio que nos informa quando algo acontece. Usando TimeCurrent(), perguntamos ao computador: “Que horas são agora?”

Quando usamos TimeCurrent(), o computador nos informa a hora atual em um formato especial, como “2024.01.15 12:30:00”. Essa informação pode ser usada para saber quando certos eventos ocorreram ou para planejar ações. Este é um relógio que sempre mostra a hora atual no mundo da programação.

Exemplo:

void OnStart()
  {

// Ask the magical clock for the current time
   datetime currentTime = TimeCurrent();

// Display the current time on the console
   Print("The magical clock says it's now: ", currentTime);

  }

Explicação:

“datetime currentTime = TimeCurrent();”:

• Aqui declaramos uma variável chamada currentTime do tipo datetime (um tipo de dado que contém informações sobre data e hora). Usamos a função TimeCurrent() para obter a hora atual do servidor, e o resultado é atribuído à variável currentTime.

“Print("The magical clock says it's now: ", currentTime);”:

• A função Print() é usada para imprimir mensagens no console. Nesta linha, imprimimos uma mensagem junto com o valor de currentTime, por isso ela mostra a hora atual, informada pela nossa função.
  

Em termos simples, o programa verifica a hora atual usando a função TimeCurrent() e, em seguida, nos informa o que encontrou, imprimindo uma mensagem no console.

Agora vamos considerar outro exemplo para entender melhor como a função funciona. Este é um exemplo um pouco mais complexo do uso da função TimeCurrent(). Vou mostrar um cenário onde verificamos se a hora atual do servidor corresponde a um momento pré-determinado. Esta é outra maneira de usar as funções de tempo no MQL5. Na verdade, existem muitas e muitas maneiras de utilizá-las!

Exemplo:

void OnStart()
  {

// Declaration of datetime variable
   datetime magicalClock;

// Assigning a special date and time to our magical clock
   magicalClock = D'2024.01.15 12:30:00';

// Check if TimeCurrent is equal to our magical clock
   if(TimeCurrent() == magicalClock)
     {
      Print("The magic moment has arrived!");
     }
   else
     {
      Print("Not yet the magic time...");
     }

  }

Explicação:

“datetime magicalClock;”:

• Declara uma variável chamada magicalClock do tipo datetime.

“magicalClock = D'2024.01.15 12:30:00';”:

• Atribui uma data e hora específicas (15 de janeiro de 2024, 12:30) à variável magicalClock, usando o prefixo D para literais datetime.

“if (TimeCurrent() == magicalClock) { ... }”:

• Compara a hora atual do servidor (TimeCurrent()) com o valor pré-determinado magicalClock. Se forem iguais, a frase "The magic moment has arrived!" é impressa no console; caso contrário, a mensagem "Not yet the magic time..." é exibida.
  

Ao estudar MQL5 e negociação algorítmica, alguns conceitos podem ser confusos, especialmente para iniciantes. É normal que o processo de aprendizado inclua a busca por respostas e esclarecimentos. Não hesite em fazer qualquer pergunta — sobre arrays, funções personalizadas, preprocessadores, manipulação de eventos ou qualquer outro tópico que tenhamos abordado.

Programar, assim como qualquer outra habilidade, pode parecer um pouco complicado no início, mas trabalhando juntos, podemos tornar essa jornada mais agradável e compreensível. A singularidade da nossa experiência de aprendizado reside nas perguntas que fazemos e nas discussões que temos. Seja um participante ativo no processo de aprendizado.

3.2.2. TimeGMT

A função TimeGMT() no MQL5 permite trabalhar com o Tempo Médio de Greenwich (GMT). GMT é o relógio universal que as pessoas em todo o mundo usam como referência. É uma medida de tempo padronizada em todo o mundo. Na negociação algorítmica, essa função facilita a coordenação e a sincronização de ações em escala global, fornecendo uma base comum para operações relacionadas ao tempo.

A função TimeGMT no MQL5 retorna a hora atual em GMT com ajuste para o horário de verão (DST) com base no horário local do computador onde o terminal cliente está sendo executado. Com esse ajuste, o GMT retornado considera se o horário de verão está em vigor no momento.

Analogia

Imagine que na cidade especial de Greenwich há um relógio. Essa cidade é como a sede dos guardiões do tempo. O tempo no relógio de Greenwich é considerado o tempo padrão que todos no mundo seguem. Agora suponha que você tem amigos em diferentes lugares, cada um com seu horário local. Se você quiser planejar uma reunião virtual com eles, pode ser complicado porque todos têm horários diferentes em seus relógios.

É aí que o GMT ajuda. Esse tempo permite que todos se sincronizem. GMT é o tempo no relógio de Greenwich, e quando você sabe a hora atual, fica mais fácil coordenar ações com seus amigos, onde quer que eles estejam. Assim, GMT é o tempo de referência que ajuda as pessoas de diferentes lugares a concordarem sobre quando fazer algo juntos.

Imagine que na nossa cidade de Greenwich, às vezes, em determinados períodos do ano, os relógios são ajustados. Este é um evento especial. Daí surge o horário de verão (DST), que é diferente do horário normal. Por isso, é necessário saber se os relógios estão em horário de verão ou não. A função TimeGMT() no MQL5 informa esse tempo de referência, considerando se os relógios estão em horário de verão ou não.

Na programação, essa informação é crucial, pois permite que os traders e algoritmos rastreiem o tempo com precisão, considerando quaisquer mudanças. TimeGMT() sempre informa a hora correta, levando em conta as transições entre horário de verão e horário padrão.

Exemplo:

void OnStart()
  {

// Declaration of a variable to store GMT time
   datetime gmtTime;

// Assigning the current GMT time to the variable
   gmtTime = TimeGMT();

// Printing the GMT time
   Print("Current GMT Time: ", TimeToString(gmtTime));

  }

Explicação:

“datetime gmtTime;”:

• Nesta linha, é declarada uma variável chamada gmtTime do tipo datetime. datetime é um tipo de dado no MQL5 usado para representar valores de data e hora.
  

“gmtTime = TimeGMT();”:

• Esta linha atribui a hora atual em Greenwich à variável gmtTime. A função TimeGMT() é chamada para obter a hora atual em Greenwich.
  

“Print("Current GMT Time: ", TimeToString(gmtTime));”:

• Com a função Print, uma mensagem é impressa no console. É a mensagem "Current GMT Time: ", seguida pela hora GMT convertida em string usando a função TimeToString(gmtTime).
  

Assim, este trecho de código declara uma variável para armazenar o tempo GMT, atribui a essa variável a hora atual de Greenwich e, em seguida, imprime uma mensagem no console com a hora atual de Greenwich.

3.2.3. TimeLocal

A função TimeLocal() no MQL5 é semelhante a ajustar o relógio para o horário local do seu computador. Ela permite saber que horas são no seu local geográfico específico. Ao usar TimeLocal(), você obtém a hora pelos relógios do sistema do seu computador, sem ajuste para fusos horários globais.

Suponha que você esteja em Nova York, e os relógios do seu computador estejam ajustados para o horário de Nova York. TimeLocal() informará a hora atual com base no relógio do seu computador, facilitando a adaptação à sua rotina diária e configurações de horário local. Essa função é útil se você deseja trabalhar com o tempo no contexto do seu fuso horário, sem se preocupar com as diferenças globais.

Analogia

Imagine um relógio que mostra a hora local. A função TimeLocal no MQL5 pergunta ao seu relógio: “Que horas são aqui, onde estou?” Ela mostra a hora de acordo com suas condições locais.

Exemplo:

void OnStart()
  {

// Declaration of a variable to store local time
   datetime localTime;

// Assigning the current local time to the variable
   localTime = TimeLocal();

// Printing the local time
   Print("Current Local Time: ", TimeToString(localTime));

  }

Explicação:

Este código pede ao computador para usar a função TimeLocal() para saber a hora no seu local específico. Depois, ele exibe a hora na tela. Então, se seu relógio fosse um programa de computador, é assim que ele mostraria a hora na sua sala!

3.2.4. TimeGMTOffset

A função TimeGMTOffset() no MQL5 permite encontrar a diferença de tempo entre o seu horário local e o GMT (Greenwich Mean Time). “Quantas horas meu horário está à frente ou atrás do horário padrão global?”

Fórmula:

TimeGMTOffset = TimeGMT() − TimeLocal()

TimeGMTOffset é uma função conveniente que determina a diferença de tempo (deslocamento) em segundos entre o GMT e o horário local do computador onde o terminal de negociação está sendo executado.

Analogia

Imagine que seu relógio funciona de uma maneira um pouco diferente. Ele não apenas mostra a hora, mas também a diferença do seu horário em relação ao horário de referência que todos no mundo seguem. Este horário de referência é o GMT. Em vez de fazer cálculos matemáticos complicados para descobrir quanto o seu horário difere do GMT, você tem um botão mágico chamado TimeGMTOffset. Quando você pressiona este botão, você obtém uma resposta direta: quantos segundos seu horário está à frente ou atrás do horário mundial.

Se você quiser planejar algo simultaneamente com amigos de diferentes lugares em diferentes fusos horários, esse botão ajudará a determinar quando se encontrar, sem a necessidade de calcular tudo sozinho. É um assistente que garante que todos estejam na mesma sintonia, onde quer que estejam!

Exemplo:

void OnStart()
  {

// Declaration of variables
   int gmtOffsetSeconds, gmtOffsetMinutes;

// Assigning the current GMT offset to the variable in seconds
   gmtOffsetSeconds = TimeGMTOffset();

// Converting seconds to minutes
   gmtOffsetMinutes = gmtOffsetSeconds / 60;

// Printing the GMT offset in minutes
   Print("Current GMT Offset (in minutes): ", gmtOffsetMinutes);

  }

Explicação:

“int gmtOffsetSeconds, gmtOffsetMinutes;”:

• Aqui, declaramos duas variáveis (gmtOffsetSeconds e gmtOffsetMinutes) para armazenar o deslocamento de Greenwich em segundos e minutos, respectivamente.
  

“gmtOffsetSeconds = TimeGMTOffset();”:

• Usamos a função TimeGMTOffset() para obter o deslocamento atual do GMT em segundos. Atribuímos esse valor à variável gmtOffsetSeconds.
  

“gmtOffsetMinutes = gmtOffsetSeconds / 60;”:

• Para converter o deslocamento GMT de segundos para minutos, dividimos gmtOffsetSeconds por 60 e armazenamos o resultado em gmtOffsetMinutes.
  

“Print("Current GMT Offset (in minutes): ", gmtOffsetMinutes);”:

• Finalmente, imprimimos no console o deslocamento em minutos. A função Print exibe o texto entre aspas junto com o deslocamento GMT calculado em minutos.
  

Neste código, primeiro obtemos o deslocamento de Greenwich em segundos usando TimeGMTOffset(), depois dividimos esse valor por 60 para convertê-lo em minutos. E exibimos a informação em minutos. Se você executar o script com este código, ele exibirá o deslocamento GMT em minutos.

Um deslocamento GMT de -60 significa que a hora local está 60 minutos à frente do GMT.

3.2.5. TimeToStruct

No MQL5, a função TimeToStruct() é usada para converter um timestamp (representado como a quantidade de segundos passados desde 1º de janeiro de 1970) em um formato estruturado. Esse formato estruturado é representado pela estrutura predefinida MqlDateTime, que inclui elementos separados para ano, mês, dia, hora, minuto e segundo.

Exemplo:

void OnStart()
  {

// Declare an MqlDateTime variable
   MqlDateTime myTime;

// Convert the current timestamp to a structured format
   TimeToStruct(TimeCurrent(), myTime);

// Access individual components of the structured time
   Print("Current Year: ", myTime.year);
   Print("Current Month: ", myTime.mon);
   Print("Current Day: ", myTime.day);
   Print("Current Hour: ", myTime.hour);
   Print("Current Minute: ", myTime.min);
   Print("Current Second: ", myTime.sec);

  }

No exemplo acima, TimeCurrent() retorna o timestamp atual, e TimeToStruct converte esse timestamp em um formato estruturado, armazenado na variável myTime do tipo MqlDateTime. Após a conversão, você pode acessar componentes específicos do tempo (ano, mês, dia, etc.) usando os elementos da estrutura myTime.

Nota: explicações adicionais sobre o funcionamento de MqlDateTime serão apresentadas posteriormente.

Analogia

Vamos considerar o que TimeToStruct() faz. Imagine que você tem um grande acúmulo de segundos, que começou a ser contado em 1970 (o ponto de partida na cronometragem de computadores). Esses segundos se acumulam, e precisamos saber quantas horas, minutos, dias e até anos estão contidos nesse grande número.

É aqui que TimeToStruct() entra em ação. Ela pega esse enorme montante de segundos e os divide em um formato mais conveniente para os humanos. E se temos um grande número, como 100.000 segundos, TimeToStruct() nos informará que isso equivale a 27 horas, 46 minutos e 40 segundos. É uma calculadora que converte um simples número de segundos em uma divisão detalhada do tempo, começando do ponto de partida em 1970.

Imagine que você tem uma cápsula do tempo chamada MqlDateTime, e quando você entrega a ela um momento específico (por exemplo, a hora atual) ela se abre e revela detalhes. A função TimeToStruct() transforma segundos brutos desde 1970 em um conjunto de informações organizadas.

Se você tiver um contador de segundos, TimeToStruct() agitará sua varinha mágica, e você terá uma visão clara dos anos, meses, dias, horas, minutos, segundos, dias da semana e dias do ano — tudo bem organizado na estrutura MqlDateTime. O código temporal enigmático se transforma em um formato legível, tornando seus programas mais versáteis e práticos.

Exemplo:

void OnStart()
  {

// Declare an MqlDateTime variable
   MqlDateTime myTime;

// Convert the number of seconds into a structured format
   TimeToStruct(100000, myTime);

// Now, myTime will tell us the breakdown since 1970
   Print("Years: ", myTime.year);
   Print("Months: ", myTime.mon);
   Print("Days: ", myTime.day);
   Print("Hours: ", myTime.hour);
   Print("Minutes: ", myTime.min);
   Print("Seconds: ", myTime.sec);

  }

Explicação:

“MqlDateTime myTime;”:

• Nós declaramos uma estrutura chamada myTime, usando MqlDateTime.
  

“TimeToStruct(100000, myTime);”:

• Aqui usamos TimeToStruct para converter a quantidade de segundos (neste caso, 100.000) em um formato estruturado, armazenado em myTime. Assim, deciframos um momento específico no tempo.
  

“Print("Years: ", myTime.year);”:

• Agora pedimos para mostrar os anos, começando de 1970, usando o atributo year. O mesmo vale para meses, dias, horas, minutos e segundos.
  

Temos um momento no tempo (100.000 segundos desde 1970) e pedimos para dividi-lo em anos, meses, dias, e assim por diante. Assim podemos entender a que momento no tempo estamos nos referindo. Interessante, não é?

Estudando as nuances das funções temporais no MQL5, assim como qualquer outro aspecto da programação, não se esqueça de fazer perguntas. Passo a passo, exploramos novas áreas da programação. Se algo parecer confuso, faça perguntas nos comentários.

Nota: a introdução de hoje ao MqlDateTime é apenas o começo. Continuaremos a explorar detalhadamente as estruturas predefinidas no próximo artigo.

Considerações finais

Então, neste artigo, exploramos a área interessante de estruturas, classes e a concepção de tempo no MQL5. Lembre-se, aprendizado é um caminho dinâmico no qual você é um participante ativo. Se restarem dúvidas, não hesite em perguntar para que nada fique confuso. Acompanhe os próximos artigos desta série, onde avançaremos para novos níveis de programação MQL5. Bom código e bons trades!