Você está na página 1de 121

EAFXTRADE

MQL4
Desenvolvendo seu Robô
Flávio Moraes

17
1
Sumário
Introdução ..................................................................................................................................... 5
Introdução à programação MQL4 ................................................................................................. 6
Noções básicas de MQL4 ........................................................................................................... 9
Alguns conceitos básicos ......................................................................................................... 10
A noção de um tick .............................................................................................................. 10
A noção de controle ............................................................................................................ 10
A noção de comentário ....................................................................................................... 11
Constantes e variáveis............................................................................................................. 12
Constantes........................................................................................................................... 12
Variável................................................................................................................................ 12
Tipos de dados ........................................................................................................................ 13
Tipo int ................................................................................................................................ 13
Tipo double.......................................................................................................................... 14
Tipo boll ............................................................................................................................... 14
Tipo string............................................................................................................................ 14
Tipo color............................................................................................................................. 15
Tipo datetime ...................................................................................................................... 17
Operações e Expressões.......................................................................................................... 17
As noções de operando, operação, símbolo de operação e expressão .............................. 17
Tipos de operações ............................................................................................................. 18
Operadores.............................................................................................................................. 21
Tipos de operadores............................................................................................................ 21
Funções ................................................................................................................................... 22
Tipos de programas ................................................................................................................. 24
Meta Editor ................................................................................................................................. 26
Sistema de arquivo .................................................................................................................. 26
Criando e usando programas .................................................................................................. 27
Programa em MQL4 .................................................................................................................. 34
Estrutura do programa em MQL4 ........................................................................................... 34
Ambiente de Desenvolvimento do MT4 ................................................................................. 36
Estrutura do programa ............................................................................................................ 36
Parte do cabeçalho .............................................................................................................. 37

2
Funções especiais ................................................................................................................ 37
Funções definidas pelo usuário ........................................................................................... 40
Funções padrão ................................................................................................................... 41
Seqüência de execução do código ...................................................................................... 43
Execução do programa ........................................................................................................ 46
Operadores ................................................................................................................................ 55
Operador de Atribuição .......................................................................................................... 55
Operador condicional 'if - else' ............................................................................................... 57
Exemplo 1 ............................................................................................................................ 58
Exemplo 2 ............................................................................................................................ 59
Exemplo 3 ............................................................................................................................ 61
Exemplo 4 ............................................................................................................................ 62
Exemplo 5 ............................................................................................................................ 64
Operador while e for ............................................................................................................... 65
Operador while ................................................................................................................... 65
Operador for........................................................................................................................ 69
Operador break ....................................................................................................................... 72
Operador Continue ................................................................................................................. 75
Operador switch ...................................................................................................................... 77
Chamada de função ................................................................................................................ 81
Variáveis ...................................................................................................................................... 84
Variáveis predefinidas e função RefreshRates() ..................................................................... 84
Lista de Nomes Predefinidos Simples de Variáveis ................................................................. 84
Lista de nomes predefinidos de matrizes-Timeseries ............................................................. 84
Propriedades de variáveis pré-definidas ................................................................................. 84
Função RefreshRates () ........................................................................................................... 87
Tipos de Variáveis.................................................................................................................... 89
Variáveis locais e globais ..................................................................................................... 89
Variáveis estáticas ............................................................................................................... 90
Variáveis externas ............................................................................................................... 91
GlobalVariables ................................................................................................................... 93
Matrizes............................................................................................................................. 100
Programação prática em MQL4 ............................................................................................ 112
Programação de Operações Comerciais ............................................................................... 112

3
Maneira comum de começar ............................................................................................ 112
Características e Regras de Ordem para Fazer Negócios .................................................. 118

4
Introdução

Hoje em dia, um computador pessoal tornou-se indispensável para todos. O rápido


desenvolvimento da Internet e do desempenho dos computadores modernos abriu novas
perspectivas em muitos campos das atividades humanas. Já há dez anos, o mercado financeiro
estava disponível apenas para bancos e para uma comunidade limitada de especialistas. Hoje,
qualquer um pode se juntar ao mundo dos comerciantes profissionais e iniciar a negociação
independente a qualquer momento.

Milhares de pessoas em todo o mundo já aprovou o uso do MetaTrader 4 pelo seu


desempenho. O uso de sua linguagem de programação embutida, MQL4, eleva os comerciantes
para um novo nível de negociação - para negociação automatizada.

Agora, um comerciante pode implementar suas idéias como um programa de aplicação -


escrever um indicador personalizado, um script para executar operações únicas, ou criar um
Expert Advisor - um sistema de negociação automatizado (robô comercial).

Um Expert Advisor (EA) pode trabalhar 24 horas por dia, 7 dias por semana, sem qualquer
intervenção - acompanhar os preços com segurança, e enviar mensagens eletrônicas, para o
seu celular, bem como fazer muitas outras coisas úteis.

A principal vantagem das aplicações é a possibilidade de fazer negócios de acordo com o


algoritmo definido por você. Qualquer idéia que possa ser descrita em uma linguagem
algorítmica (interseção de duas médias móveis ou processamento digital de sinais, três telas
por análise fractal de Elder ou Peters, uma rede neural ou construções geométricas) pode ser
codificada em uma aplicação.

O desenvolvimento de aplicações para MetaTrader 4 requer o conhecimento do MQL4. Este


livro de texto irá ajudá-lo a criar seus próprios Expert Advisors, scripts e indicadores. Este E-
book didático destina-se a um grande número de leitores sem experiência em programação que
desejam aprender a desenvolver aplicativos de negociação automatizados para MetaTrader 4
Client Terminal. O livro projetado de tal forma que qualquer pessoa vai dar conta de
implementar seus próprios Robôs automatizados.

5
Introdução à programação MQL4

Antes de começar a estudar a programação MQL4, vamos definir o escopo do nosso estudo. Em
primeiro lugar, deve-se notar que os programas discutidos neste livro podem ser usados apenas
como aplicativos para trabalhar no MetaTrader 4 Client Terminal. A ilustração a seguir
mostra o papel desses programas na gestão das negociações. Vejamos a ilustração.

Figura 1 Um programa desenvolvido na linguagem MQL4 como parte do MetaTrader 4


Terminal Cliente.

Se você estiver interessado em programação MQL4, você já deve ter se familiarizado com o
terminal MetraTrader 4. O terminal do cliente (Metatrader 4) é uma parte do sistema de
comércio on-line. Este sistema de comércio on-line também inclui um servidor instalado em um
centro de negociação. O centro de negociação está conectado com outros participantes do
mercado, como bancos e instituições financeiras.

O terminal cliente inclui um ambiente informacional, um conjunto de parâmetros com


informações sobre o estado de mercado e sobre as relações entre um comerciante e um centro
de negociação. Esses parâmetros incluem informações sobre preços atuais, limitações no
tamanho máximo e mínimo da ordem, distância mínima de ordens de parada, tolerância e
proibição da negociação automatizada e muitos outros parâmetros úteis que caracterizam o
estado atual. O ambiente informacional é atualizado quando novos sinais são recebidos pelo
terminal (linha verde na Figura 1 anterior).

6
Controles do MetaTrader 4

O terminal cliente contém ferramentas internas que lhe permitem realizar análises técnicas do
mercado e executar a gestão comercial manual. Para análise de mercado, você pode usar
indicadores técnicos e vários estudos de linha de suporte / linhas de resistência, canais de
tendência, níveis de Fibonacci e assim por diante.

Para a gestão comercial manual, a barra de ferramentas de gestão de pedidos é


utilizada. Usando esta barra de ferramentas, um comerciante pode abrir, fechar e modificar
ordens. Além disso, o terminal tem a opção de gerenciamento automatizado da posição de
ordem de parada. As ações de um trader com ferramentas de gerenciamento de negociação
incorporadas resultam na formação de ordens comerciais, que são enviadas para um servidor.

Ferramentas de programação MQL4

Análise de mercado e gestão comercial no MetaTrader 4 é implementado com a ajuda de


ferramentas de programação.

A linguagem MQL4 permite a criação de tais programas.

Existem três tipos de aplicativos criados em MQL4 e destinados a trabalhar no terminal


cliente:

1. Um indicador personalizado é um programa que exibe graficamente as


regularidades do mercado de acordo com o algoritmo de um autor escrito no
programa.
2. Um Expert Advisor é um programa que permite a automação parcial de
operações de negociação, ou permite negociação totalmente automatizada.
3. Um script é um programa para executar ações únicas, incluindo a execução de
operações comerciais.

A Figura 1 mostra que os programas em MQL4 tem os mesmos meios de acesso ao ambiente
informacional do terminal do cliente utilizado nas negociações manuais (setas azuis).

Programas em MQL4 pode influenciar diretamente na gestão da sua conta de negociação (setas
vermelhas).

Programas de diferentes tipos podem ser usados simultaneamente e podem trocar dados entre
eles. Usando essas aplicações, um programador pode automatizar uma grande parte das
operações de negociação, ou criar um robô que irá negociar sem a interferência humana.

Aplicativos e ferramentas de gerenciamento manual podem ser usados no terminal cliente


simultaneamente, complementando um ao outro.

OBS: A característica técnica fundamental de negociação usando o sistema de comércio on-line


MetaTrader é que todas as ações de gerenciamento são produzidos no terminal do cliente e,
em seguida, enviado para um servidor. Os programas de aplicação (Expert Advisor, script e
indicador) podem funcionar apenas como parte do terminal cliente, desde que estejam
conectados a um servidor (centro de negociação). Nenhum dos programas de aplicação fica
instalado no servidor.

7
O servidor só processará sinais provenientes de um terminal cliente. Se um terminal cliente
estiver desconectado da Internet ou se um programa aplicativo (Expert Advisor ou script)
executado nele não gerar nenhuma ação de gerenciamento, nada acontecerá no servidor.

O escopo do nosso estudo inclui programas (Expert Advisors, scripts e indicadores


personalizados) que realizam negociações parcialmente ou totalmente automatizadas e que
ampliam significativamente a manutenção informacional da negociação (ver Figura 1). Neste
livro, você encontrará a descrição dos componentes do programa, e você encontrará as
principais regras de criação e uso de programas. Também vamos considerar em pormenor
exemplos de programas e exemplos de parâmetros de ambiente informacional do terminal
cliente, que estão disponíveis para um programa durante a sua execução.

OBS: Os programas para negociação automatizada têm muito mais usos potenciais do que as
ferramentas manuais de gerenciamento comercial.

Na maioria dos casos, um programa em MQL4 torna o trabalho de um profissional negociador


mais fácil, eliminando a necessidade de um acompanhamento constante de situações de
mercado, sentado diante de um computador por um longo período de tempo.

Também pode ajudar a aliviar a tensão nervosa e a diminuir o número de erros que aparecem
em períodos de extrema tensão emocional. Mas, o principal é que o uso do método do
programa de gestão do comércio permite que os comerciantes desenvolvam suas próprias
idéias e testá-los em dados históricos, selecionar parâmetros ótimos para aplicar essas idéias e,
finalmente, implementar uma estratégia de negociação pensada.

8
Noções básicas de MQL4

Esta seção representa os termos básicos para entender o MQL4:

1. alguns conceitos básicos

Termos básicos são descritos, tais como tick (a mudança de preço), controle de
algoritmos, e comentário em programas.
O principal evento quando a negociação em mercados financeiros é a mudança
de preço. É por isso que tick é um evento importante que faz com que os
mecanismos básicos dos programas MQL4 sejam executados.
O que acontece quando um novo tick entra?
Que ações o terminal deve tomar?
Veremos mais sobre o assunto, neste E-book.

2. Constantes e variáveis

Os termos constantes e variáveis são comuns quando falamos de programação


a diferença entre esses termos é explicado.
Como o termo sugere, uma constante é algo que permanece o mesmo, definido
uma vez e nunca mais muda.
Ao contrário da constante, uma variável é um objeto de código de programação
que pode ter seu conteúdo alterado a qualquer momento.
É impossível escrever um programa sem usar objetos (constantes) imutáveis e /
ou objetos que podem ser modificados durante a execução do programa
(variáveis).

3. Tipos de dados

Certos tipos de dados são usados em qualquer linguagem de programação, seja


ela em C, Delphi, Java e etc... O tipo de dados de uma variável é escolhido de
acordo com sua finalidade.
Como podemos declarar uma variável?
Como podemos inicializá-lo (predefinir seu valor inicial)?
Uma escolha errada do tipo para uma variável pode atrasar o programa ou
mesmo resultar em ações erradas.
Mostraremos como utilizar mais a frente.

4. Operações e expressões As

Como qualquer outra linguagem de programação, O MQL4 processa toda forma


de operações e executa qualquer tipo de expressões criadas pelo desenvolvedor.
Sem saber sobre os recursos de algumas operações, você pode fazer erros sutis.

5. Operadores

Existem operadores simples e operadores compostos. Uma ação necessária não


deve sempre ser executada por um operador simples. Se for necessário que um
grupo de operadores seja executado como um grande operador, esse grupo deve
ser incluído em um operador composto. Requisitos e exemplos específicos de
utilização de operadores são dados mais a frente.

9
6. Funções

A necessidade de criar funções nos leva ao termo função . Para usar a função de
diferentes localizações no programa, é necessário fornecer-lhe parâmetros
de função . Vamos considerar o processo para criar uma função
personalizada. Exemplos de utilização de funções padrão são fornecidos.

7. Tipos de

Programas Scripts, indicadores e Expert Advisors são os tipos de programas MQL4


que permitem cobrir praticamente toda a classe de problemas relativos à
negociação em mercados financeiros. É necessário compreender as finalidades de
cada tipo de programas para usar MetaTrader 4 Client Terminal da melhor
maneira.

Alguns conceitos básicos


O assunto de nosso interesse aqui é criar um programa escrito em MQL4. Antes de iniciar uma
apresentação detalhada das regras da escrita de programas, é necessário descrever os
conceitos básicos que caracterizam um programa e suas inter-relações com o ambiente de
informação. O MetaTrader 4 Client Terminal funciona com uma conexão on-line. A situação nos
mercados financeiros muda continuamente, o que afeta gráficos de símbolos no terminal do
cliente. Os Ticks fornecem ao terminal cliente informações sobre as mudanças de preços no
mercado.

A noção de um tick

Um tick é um evento que é caracterizado por um novo preço do símbolo em algum instante.

Os Ticks são entregues a cada terminal do cliente por um servidor que está instalado em um
centro de negociação. Conforme a situação atual do mercado, os Ticks são atualizados sempre
que houver mudança nos preços, e podem ser recebidos mais ou menos freqüentemente, mas
cada um deles traz uma nova cotação de preço.

Por exemplo, um Expert Advisor (EA) não fica funcionando o tempo todo. Um EA é ativado no
momento que cada tick é recebido pelo terminal cliente. Por esta razão, não caracterizamos tick
como apenas uma nova cotação, mas como um evento a ser processado pelo terminal cliente.

A duração da operação de uma EA depende do que foi programado para ele fazer. Normal EAs
completar um ciclo de processamento de informações durante alguns décimos ou centésimos
de segundo. Dentro deste período, o EA pode ter processado alguns parâmetros, feito uma
decisão de negociação, desde o comerciante com algumas informações úteis e assim por
diante. Tendo terminado esta parte do seu trabalho, a EA vai para o modo de espera até um
novo Tick ser recebido pelo Terminal Cliente. Este novo tick lança o EA novamente, o programa
faz as operações apropriadas novamente e retorna ao modo de espera. A descrição detalhada
de como o aparecimento de um novo tick influencia a operação do programa segue a seguir.

A noção de controle

10
Controle é o termo usado para falar sobre o fluxo de execução de código dentro de um
programa, bem como o fluxo entre o programa e o terminal do cliente.

Controle é o processo de execução de ações predefinidas pelo algoritmo do programa e os


recursos do terminal do cliente. O controle pode ser transferido dentro do programa de uma
linha de código para outra, bem como do programa para o terminal do cliente.

Antes de iniciar o EA, o controle está sob a supervisão do terminal cliente. Uma vez que o EA é
iniciado e um novo Tick é recebido, o terminal cliente transfere o controle para o EA. O código
do programa começa a ser executado neste momento.

O terminal cliente, depois de ter transferido o controle para o programa, não interrompe sua
operação. Ele continua trabalhando com o desempenho máximo durante todo o período de
tempo em que é iniciado no PC. O programa só pode começar a operar no momento em que o
terminal cliente transferiu o controle para ele.

A noção de comentário

Um comentário é uma parte opcional e não executável de um programa que explica o código.
Portanto, o comentário é uma parte opcional de um programa. Isso significa que um programa
pronto funcionará de acordo com seu código, independentemente de haver comentários ou
não.

No entanto, os comentários facilitam a compreensão do código do programa. Meu conselho é


que sempre comente o seu código, veja o exemplo:

11
Constantes e variáveis
Constantes

Constante nada mais é do que parte de um programa.

Uma constante em um programa é semelhante a uma constante usada em equações


matemáticas. É um valor invariável. NUNCA MUDA.

Exemplos:

A raça humana descobriu constantes naturais, universais, cujos valores não dependem de nós
de modo algum. Por exemplo, em física, a aceleração de queda livre é sempre igual a
9,8 m / s / s ;

Em matemática, Pi = 3,14.

Constante é também um termo usado em equações matemáticas. Por exemplo, na equação


de Y = 3 * X + 7, os números 3 e 7 são constantes. Os valores de tais constantes são
totalmente dependentes da vontade da pessoa que fez a equação. Esta é a analogia mais
próxima das constantes usadas em programas MQL4.

Veja a imagem um exemplo de constante no Código MQL4.

Variável

Ao Contrário da constante, as variáveis podem ser alteradas a qualquer momento dentro do


programa, o valor recebido por uma determinada variável fica armazenada somente na
memoria do computador, e essa variável pode receber outro valor sempre que for necessário.

12
Veja o Exemplo de uma Variável.

Tipos de dados
Acima falamos de constantes e variáveis, agora vou mostrar para vocês os tipos de dados
utilizados na hora de declarar uma variável em MQL4.

As variáveis podem ser:

 int (números inteiros)


 double (números com casas decimais)
 bool (valores booleanos, que são valores lógicos (true ou false))
 string (valores do tipo texto)
 color (valores do tipo de cor)
 datetime (valores de data e hora)

Tipo int

13
Os valores de tipo Int são inteiros, também conhecidos como números inteiros. Esse tipo inclui
valores que são inteiros por sua natureza.

Int Art = 10 ; // Exemplo de variável inteira


int B_27 = - 1 ; // Exemplo integer variável
int Num = 21 ; // Exemplo inteiro variável
int Max = 2147483647 ; // Exemplo inteiro variável
int Min = - 2147483648 ; // Exemplo de variável inteira

Tipo double

As variáveis do tipo double são números reais que contêm uma parte fracionária.

Os valores de exemplo deste tipo podem ser quaisquer valores que tenham uma parte
fracionária.

double Art = 10,123 ; // Exemplo de variável real


double B_27 = - 1,0 ; // Exemplo de variável real
double Num = 0,5 ; // Exemplo variável real
double MMM = - 12,07 ; // Exemplo de variável real
double Price_1 = 1,2756 ; // Exemplo de variável real

Tipo boll

Os valores de um tipo bool são valores de tipo booleano (lógico) que contêm falsidade ou
verdade. Essas variáveis podem receber valores como True e False ou 1 e 0 veja o
exemplo:

bool aa = True; // Variável booleana аа tem o valor de true


bool B17 = TRUE; // A variável booleana B17 tem o valor de true
bool Hamma = 1; // Variável booleana Hamma tem o valor de true
bool Asd = False; // Variável booleana Asd tem o valor de false
bool Nol = FALSE; // A variável booleana Nol tem o valor de false
bool Prim = 0; // A variável booleana Prim tem o valor de false

Tipo string

Valores de um tipo string são aqueles representados como um conjunto de caracteres ASCII.

14
string Prefix = "MetaTrader 4" ; // Exemplo variável string
string Postfix = "_of_my_progr. OK" ; // Exemplo variável string
string Name_Mass = "Histórico" ; // Exemplo variável string
string text = "Linha Superior \nLinha Baixa" ; // o texto contém caracteres
de alimentação de linha

Tipo color

As cores são armazenados como cor tipos de dados.

O significado de "cor" (azul, vermelho, branco, amarelo, verde e assim por diante) é de
conhecimento comum. É fácil imaginar o que uma variável ou uma constante do tipo de color
pode significar. É uma constante ou uma variável, cujo valor é uma cor. Pode parecer um pouco
incomum, mas é muito simples, geralmente falando. Como o valor de uma constante de
número inteiro é um número, o valor de uma constante de cor é uma cor.

Os valores de constantes e variáveis de cores podem ser representados como um dos três tipos:
literais, representações inteiras e nomes de cores.

Literais

O valor do tipo de cor representado como um literal consiste em três partes que representam os
valores numéricos da intensidade de três cores básicas: vermelho, verde e azul (RGB). O valor
deste tipo começa com 'C' e é citado por aspas simples.

Os valores numéricos da intensidade RGB variam de 0 a 255, e podem ser gravados decimal e
hexadecimal.

Exemplos: C'128,128,128 '(cinzento), C'0x00,0x00,0xFF' (azul), C'0xFF, 0x33,0x00 '(vermelho).

Representação de inteiro

A representação de inteiro é registrada como um número hexadecimal ou decimal. Um número


hexadecimal é exibido como 0xRRGGBB, onde RR é o valor de intensidade vermelha, GG de
verde e BB de azul. As constantes decimais não são refletidas diretamente no RGB. Eles
representam o valor decimal de uma representação hexadecimal inteiro.

Representação dos valores de tipo de cor como inteiros e como hexadecimais literais é muito
amigável. A maioria dos editores modernos de texto e gráficos fornece informações sobre a
intensidade dos componentes vermelho, verde e azul no valor selecionado de cor. Basta
selecionar uma cor em seu editor e copiar os valores encontrados em sua descrição para a
representação do valor de cor correspondente em seu código.

Exemplos: 0xFFFFFF (branco), 0x008000 (verde), 16777215 (branco), 32768 (verde).

Em MQL4 A maneira mais fácil de definir uma cor é especificar seu nome de acordo com a
tabela de cores. Neste caso, o valor de uma cor é representado como uma palavra
correspondente à cor, por exemplo, Vermelho representa a cor vermelha. Veja a tabela:

15
16
Tipo datetime

O tipo de dados datetime é usado para data e hora.

Valores desse tipo podem ser usados em programas para analisar o momento de início ou
término de alguns eventos, por exemplo, a liberação de notícias importantes, início / fim do dia
de trabalho e assim por diante. As constantes de data e hora podem ser representadas como
uma linha literal composta de seis partes que representam os valores numéricos de ano, mês,
dia (ou dia, mês, ano), hora, minuto e segundo.

A constante começa com "D" e é enquadrada em aspas simples. Você também pode usar
valores truncados sem data, ou sem tempo, ou apenas como um valor vazio. O intervalo de
valores é de 1 de janeiro de 1970 até 31 de dezembro de 2037. Os valores de constantes e
variáveis de tipo de data e hora tomam 4 bytes na memória do computador. Um valor
representa a quantidade de segundos decorridos desde 00:00 de 1 de janeiro de 1970.

Aqui estão alguns exemplos de como usar uma variável do tipo datetime em um programa.

datetime Alfa = D'2004.01.01 00:00'; // Novo Ano


datetime Tim = D'01.01.2004'; // Novo Ano
datetime Tims = D'2005.05.12 16:30:45'; // May 12, 2005 4:30:45 p.m.
datetime N_3 = D'12.05.2005 16:30:45'; // May 12, 2005 4:30:45 p.m.
datetime Compile = D''; // equivalent of D'[compilation
date] 00:00:00'

Operações e Expressões
Para entender o significado de operações e expressões em MQL4, não são necessárias
analogias especiais. Praticamente, é o mesmo que operações e expressões na aritmética
simples. Todo mundo entende que no registro f = n + m , membros f , n , e m são variáveis,
sinais = e + são sinais operacionais e n + m é uma expressão.

Na seção anterior do livro, você aprendeu sobre a necessidade de apresentar dados de


diferentes tipos. Aqui vamos entrar em possíveis relações entre esses dados. Em MQL4, existem
algumas limitações naturais para as regras de utilização de operações em expressões.

As noções de operando, operação, símbolo de operação e expressão

Operando é uma constante, uma variável, um componente de matriz ou um valor retornado por
uma função. (As funções são consideradas na seção sobre as funções , as matrizes são
consideradas na seção sobre arrays , neste estágio atual de aprendizagem, é suficiente para
entender os operandos como constantes e variáveis que já estudamos).

Uma operação é uma ação feita sobre operandos .

17
Um símbolo de operação é um caractere predefinido ou grupo de caracteres que ordenam
executar uma operação.

Uma expressão é uma seqüência de operandos e símbolos de operação;

Tipos de operações

Estes são os seguintes tipos de operações em MQL4:

 Aritmética
 Atribuição
 Relacional
 Boolean
 Bit a bit
 Comma
 Chamada de função

Operações são usadas em operadores (ver Operadores ). Somente em operadores faz seu uso
faz sentido e é realizado em um programa. A possibilidade de utilizar uma operação é
determinada pelas propriedades dos operadores; Se as propriedades do operador permitem que
você utilize esta operação específica, você pode usá-la; Caso contrário, você não deve usar esta
operação. É proibido o uso de operações fora dos operadores.

Operações aritméticas
Os seguintes símbolos são exemplos de operação aritmética.

Operações de atribuição
Os seguintes símbolos são exemplos de operação de atribuição.

18
Operações relacionais
Os símbolos a seguir são exemplos de operação relacional.

Operações booleanas (lógicas)


Os símbolos a seguir são exemplos de operação booleanos.

Operações bit a bit

Operações bit a bit só podem ser executadas com inteiros. As operações a seguir são operações
bit a bit.

Isso retorna o complemento do valor da variável. O valor da expressão contém um 1 em todos


os locais em que os valores da variável contêm um 0 e contém um 0 em todos os locais nos
quais os valores da variável contêm um 1.

B = ~n;

19
A representação binária de x é deslocada por y lugares para a direita. Esse deslocamento para
a direita é lógico; Isso significa que todos os lugares esvaziados à esquerda serão preenchidos
com zeros.

X = x >> y;

A representação binária de x é deslocada por y lugares para a esquerda; Os lugares vazios à


esquerda serão preenchidos com zeros.

X = x << y;

O exemplo seguinte demonstra a operação bit a bit E das representações binárias de x e y . O


valor da expressão contém 1 (TRUE) em todos os lugares, em que x e y contêm não-zero, e o
valor da expressão contém 0 (FALSE) em todos os outros locais.

B = ((x & y)!= 0);

O exemplo seguinte demonstra a operação bit a bit OU das representações binárias de x e y . O


valor da expressão contém 1 em todos os lugares, em que x ou y não contém 0. Ele contém 0
em todos os outros lugares.

B = x | Y;

O exemplo seguinte demonstra a operação bit a bit OU EXCLUSIVO das representações


binárias de x e y . O valor da expressão contém 1 nos lugares, nos quais x e y possuem valores
binários diferentes. Ele contém 0 em todos os outros lugares.

B = x ^ y;

Operação por vírgula

As expressões separadas por vírgulas são calculadas da esquerda para a direita. Todos os
efeitos dos cálculos na expressão esquerda ocorrem antes da expressão direita ser calculada. O
tipo e o valor do resultado coincidem com o tipo e valor da expressão direita.

for(i=0,j=99; i<100; i++,j--) Print(array[i][j]); // Loop statement

A seguinte lista de parâmetros transferidos pode ser considerada como um exemplo.

My_function (Alf, Bet, Gam, Del) // Calling for a function with arguments

Chamada de função

Uma chamada de função pode ser usada como um operador separado e ser encontrada em
qualquer lugar em um programa onde implique um determinado valor (com exceção de casos
predefinidos). O formato e as regras de execução de uma chamada de função abrangem
funções padrão (built-in) e definidas pelo usuário.

20
Uma chamada de função consiste no nome da função e na lista dos parâmetros passados entre
parênteses:

Function_name(Parameters_list) // Chamada de função como tal

Operadores
Tipos de operadores

Existem dois tipos de operadores: operadores simples e compostos.

Operadores simples

Operadores simples em MQL4 terminam com o caractere ";" (ponto e vírgula). Usando este
separador, o PC pode detectar onde um operador termina e outro começa. Um ponto e vírgula
é tão necessário em um programa como um espaço vazio é necessário em um texto normal
para separar frases. Um operador pode tomar várias linhas. Vários operadores podem ser
colocados numa linha.

Aqui estão exemplos de operadores simples.

Day_Next= TimeDayOfWeek(Mas_Big[n][0]+60); // Operador simples


Go_My_Function_ind(); // Operador simples
a=3; b = a * x + n; i++; // vários operadores na linha
Print(" Day= ",TimeDay(Mas_Big[s][0]), // um operador
" Hour=",TimeHour(Mas_Big[s][0]), // Outro Operador
" Minute=",TimeMinute(Mas_Big[s][0]),// mais um Operador
" Mas_Big[s][0]= ",Mas_Big[s][0], // todos dentro da Print
" Mas_Big[s][1]= ",Mas_Big[s][1]);

Operadores compostos (compostos)

Um operador composto consiste em vários simples separados pelo caractere ";" E é fechado em
chaves. Para poder usar vários operadores onde apenas se espera encontrar um deles, os
programadores usam um operador composto (também o chamam de "bloco" ou "bloco de
código"). A lista de operadores em um composto é separada por chaves. A presença de uma
chave de fecho marca o fim de um operador composto.

Aqui está uma utilização exemplar de um operador composto. Ele começa com o operador
condicional if (expressão) seguido por um composto. O operador composto contém uma lista de
operadores executáveis.

21
Funções
O avanço tecnológico mais importante na engenharia de computadores é a possibilidade de
criação e armazenamento de fragmentos de código separados que descrevem as regras de
processamento de dados para resolver um problema ou completar uma pequena tarefa. Tal
possibilidade também existe em MQL4.

Uma função é uma parte específica nomeada de um programa que descreve um método a ser
executado.

Vamos considerar dois aspectos das funções: descrições de função e chamadas de função.

A descrição de uma função é único, chamado parte de um programa destinado à execução.

Uma chamada de função (ou, referência de função) é um registro, cuja execução resulta na
execução da função a que se refere.

Em nossa vida cotidiana, podemos encontrar muitas funções analógicas. Tomemos, por
exemplo, o sistema de frenagem de um carro. O mecanismo de atuação que realiza
corretamente a frenagem, bem como a idéia implementada pelo engenheiro, é como uma
função, enquanto que o pedal do freio é como uma chamada da função. O motorista pressiona
o pedal para baixo, e os mecanismos de atuação executa algumas ações até parar o carro.

Da mesma forma, se uma chamada de função ocorre em um programa, então a função do


mesmo nome será chamado e executado. Ou seja, uma certa seqüência de cálculos ou outras
ações serão realizadas, como exibir uma mensagem ou abrir uma ordem. O uso geral de uma
função é fazer com que uma parte logicamente concluída do código fora do texto básico do
programa e substituí-lo apenas com a chamada para esta parte do código. Tal construção de
programa tem algumas vantagens incontestáveis.

 Primeiro, o nome da função é composto de tal maneira a ser lido facilmente.


 Em segundo lugar, é fácil ver e modificar o nome de uma função sem fazer nenhuma
alteração no código básico do programa.
 Em terceiro lugar, uma função pode ser composta como um único arquivo e usada em
outros programas. Isso libera o programador da necessidade de inserir os mesmos
fragmentos do código em cada programa recém-criado.

22
A maioria do código em MQL4 é escrito na forma de funções. Esta abordagem tornou-se
generalizada e é um padrão agora.

Exemplo de um função escrita em MQL4:

Veja que ela recebe um único parâmetro de entrada do tipo int.

Outro exemplo de função, onde parte dos cálculos é composto como uma função. O código
básico contém uma chamada de função definida pelo usuário. A descrição da função definida
pelo usuário está localizada depois do código básico.

23
Veja como é a escrita de uma função:

Isso resume no que é uma função, o que vai diferenciar uma função de outra é a parte da
funcionalidade, a parte de estrutura é igual.

Tipos de programas
Ao começar a escrever um programa em MQL4, você deve, em primeiro lugar, responder à
pergunta sobre o tipo de programas que será. O conteúdo e a funcionalidade do programa

24
dependem totalmente disso. Em MQL4, existem três tipos de programas de aplicação: EAs,
scripts e indicadores personalizados. Qualquer programa que você desenvolver irá
pertencer a um destes tipos. Todos eles têm seus propósitos e características especiais.

Um Expert Advisor (EA) é um programa codificado em MQL4 e chamado pelo terminal cliente
para ser executado em cada tick. O objetivo principal dos EAs é o controle programado sobre
os comércios. Os EAs são codificados pelos usuários. Não existem EAs incorporados no
terminal do cliente.

O script é um programa codificado em MQL4 e executado pelo terminal cliente apenas uma
vez. Scripts são destinados a executar operações que devem ser executadas apenas uma
vez. Os scripts são codificados pelos usuários. Eles não são entregues com o terminal do
cliente como programas internos.

Um indicador personalizado é um programa codificado em MQL4 e chamado pelo terminal


cliente para ser executado em cada tick. Ele é basicamente destinado a exibição gráfica de
dados preliminarmente calculados, como linhas. Indicadores não podem negociar. Existem dois
tipos de indicadores: indicadores técnicos (incorporados) e indicadores personalizados.

Você escolhe o tipo de programa a ser criado, isso vai depender da finalidade do programa
específico e das propriedades e limitações dos diferentes tipos de programas.

É importante ressaltar que se tratando de EAs, você pode anexar apenas 1 EA por janela
Gráfica.

25
Meta Editor

Nesta seção, vamos nos debruçar sobre a ordem geral de criação de programas em MQL4
usando o MetaEditor.

MetaEditor é um editor especializado multifuncional destinado a criar, editar e compilar


programas de aplicação escritos em MQL4. O editor tem uma interface amigável que lhe
permite navegar facilmente ao escrever e verificar um programa.

Veja na imagem como acessar o MetaEditor:

Sistema de arquivo
O terminal cliente reconhece os tipos de programas pela sua localização em diretórios
separados.
Todos os programas de aplicação estão concentrados no diretório ClientTerminal_folder\
experts.

EAs, scripts e indicadores personalizados que você vai usar diariamente devem estar localizados
em diretórios correspondentes, como mostrado na Figura abaixo a seguir.

Os EAs estão localizados diretamente no diretório:


ClientTerminal_folder\experts .

scripts e indicadores estão em subdiretórios:

ClientTerminal_folder\experts\scripts
ClientTerminal_folder\experts\indicadores.

26
Criando e usando programas

27
Os programas escritos em MQL4, EAs, scripts e indicadores, são criados usando o MetaEditor.

O arquivo executável do MetaEditor ( MetaEditor.exe ) é fornecido como parte do terminal do


cliente e está localizado no diretório raiz do terminal. O guia do usuário do MetaEditor é aberto
pressionando F1. Contém informações gerais necessárias para a criação de novos programas. O
editor pode ser aberto clicando no nome do arquivo MetaEditor.exe ou em um atalho no seu
desktop.

Estrutura do terminal cliente

Para a conveniência da operação, o MetaEditor possui barras de ferramentas internas:


"Navigator" ( Ctrl + D ) e "Toolbox" ( Ctrl + T ).

Criando um novo programa

Geralmente, durante a criação de um novo programa, a caixa de ferramentas e as janelas do


navegador são ocultas. Assim, a atenção de um usuário fica concentrada na criação do
programa. Para criar um novo programa, vá para o menu Arquivo do editor e clique
em Novo . Ou, use o botão para a criação de novos arquivos:

Após todas essas ações, o "Assistente de EA" oferece uma lista de tipos de programas a serem
criados.

28
Se você precisa criar um EA, marque EA e clique em Avançar . Na próxima janela é necessário
indicar o nome do EA a ser criado. Suponha que ele é chamado de EAFXTRADE_V01.mq4.

Depois de clicar em Avançar, você será direcionado para próxima tela, manipuladores de
eventos do Expert Advisor.

29
Você não precisa marcar nada nesta tela, pois as configurações faremos diretamente no código.
Agora você será levado para próxima tela Testador de Manipuladores de Eventos.

Não precisa marcar nada, basta clicar em Concluir.

Veja que o arquivo EAFXTRADE_V01.mq4 esta aberto no MetaEditor veja a figura abaixo:

30
Você vê, o código contém principalmente comentários. Já sabemos que os comentários
constituem uma parte não obrigatória de um programa e o texto dos comentários não é
processado pelo programa.

Existem três funções especiais no programa: OnInit(), OnTick() e Ondeinit().

Cada função contém apenas um Return(0).

O código de programa gerado pelo EA Wizard é apenas um padrão, usando o qual você pode
criar um novo programa. O código final do programa não contém obrigatoriamente todas as
funções especiais indicadas. Eles estão presentes apenas no padrão, porque, como regra geral,
um programa médio contém todas essas funções. Se alguma das funções não for usada, sua
descrição pode ser apagada.

OnInit(), responsável em inicializar o EA, usamos essa função para carregar variáveis, obter
todas informações necessárias para o EA começar a trabalhar.

OnTick(), essa função ela é chamada sempre que o MetaTrader, recebe uma nova cotação de
preço(Tick) de um determinado comercio. Aqui é onde o robô vai executar tudo que você
programou nele.

31
OnDenit(), responsável em liberar todas as variáveis e funções utilizadas durante o
processamento do EA. Essa função é chamada sempre que o EA é desligado.

Mais a frente iremos dar inicio nas implementações e criações de funções.

Compilação do programa
Para tornar um programa utilizável na prática, ele deve ser compilado.

Para isso, o botão (F5) no MetaEditor deve ser usado. Se um programa não
contiver quaisquer erros, ele é compilado e a seguinte mensagem ocorre na caixa de
ferramentas.

Além disso, quando um programa é compilado , um novo arquivo (EAFXTRADE_V01.ex4)


aparece no diretório correspondente (neste caso, em Terminal_directory\experts). O programa
está pronto para operação no terminal cliente MetaTrader4. Durante a compilação, a última
versão do texto de origem do programa com o mesmo nome (no nosso caso, é o arquivo
create.mq4) será salvo no mesmo diretório.

Outra coisa que acontece quando um programa é compilado é que uma linha com o nome do
EA criado aparecerá na pasta EAs da janela do navegador do terminal do cliente.

Se forem detectados erros no programa durante a compilação, o MetaEditor mostrará a


mensagem de erro correspondente. Nesse caso, você deve voltar a editar o texto de origem,

32
corrigir os erros e tentar compilar o programa novamente. Uma compilação de programas bem-
sucedida é possível somente se não houver erros no programa.

Usando um programa na prática

Se um programa aplicativo (EA, script ou indicador) tiver sido compilado com êxito e seu nome
tiver aparecido na janela do navegador do terminal do cliente, ele poderá ser usado na prática.

Para utilizar o EA, basta usar o (método "arrastar e soltar"). Isso significa que o programa será
anexado a um gráfico que você desejar. E estará pronto para execução.

Um EA e um indicador funcionarão até que um usuário termine a execução do programa


manualmente. Um script normal irá parar de operar-se após a execução de seu algoritmo.

Mostrarei detalhes mais a frente, quando estivermos concluído o desenvolvimento do nosso EA.

33
Programa em MQL4
Deve ser observado desde o início que qualquer pessoa pode programar em MQL4, embora ele
requer atenção e certo conhecimento.

Talvez alguns comerciantes esperam dificuldades em estudar programação.

É difícil para eles imaginar processos complicados em execução no interior de seus


computadores. Felizmente, os desenvolvedores de linguagem MQL4 tentou torná-lo
amplamente disponível para os usuários. Uma forma agradável de criar programas em MQL4 é
que um programador não precisa necessariamente ter um conhecimento especial sobre a
interação do terminal cliente com um sistema operacional, de características de protocolo de
rede ou de uma estrutura de compilador.

O processo de criação de programas em MQL4 é um trabalho simples e fácil. Por exemplo, um


motorista não tem que saber uma estrutura de motor para dirigir um carro. Ele só precisa
aprender a dirigir.

No entanto, antes de dirigir um carro em ruas movimentadas, cada motorista tem que passar
por treinamento. Algo como isso deve ser feito por um programador de partida, aprender
alguns princípios simples é a base para criar programas, e depois disso, lentamente começando
a aprofundar no seu desenvolvimento.

Estrutura do programa em MQL4


Nas primeiras seções, abordamos algumas noções básicas da linguagem de programação
MQL4. Agora vamos estudar como um programa é organizado em geral. Para resolver esse
problema, estudaremos seu esquema estrutural.

Como mencionado acima, o código do programa principal escrito por um programador é


colocado dentro de funções definidas pelo usuário. Em Funções, discutimos a noção e as
propriedades das funções internas e definidas pelo usuário. Resumidamente, uma função
definida pelo usuário tem uma descrição e uma chamada de função é usada para iniciar sua
execução em um programa. Uma função interna ou definida pelo usuário pode ser executada
somente depois que ela é chamada. Nesse caso, a função é chamada em alguma parte deste
programa.

As propriedades das funções especiais são descritas em detalhe em Funções especiais. Aqui,
estudamos apenas as principais informações sobre eles. Uma função especial é uma função
chamada e executada pelo terminal cliente. Distintas de funções comuns, funções especiais só
têm uma descrição, e funções especiais não são chamadas de dentro de um programa. Funções
especiais são chamadas para serem executadas pelo terminal cliente. (Há uma possibilidade
técnica de chamar funções especiais de dentro de um programa, mas vamos considerar este
método incorreto e não discuti-lo aqui.) Quando um programa é iniciado para execução em
uma janela de segurança, o terminal cliente passa controle para uma das funções
especiais. Como resultado, esta função é executada.

A regra de programação em MQL4 é a seguinte.

Isso significa que as linhas de programa que estão fora das funções especiais não podem ser
executadas. Na tentativa de compilar esse programa, o MetaEditor mostrará a mensagem de

34
erro correspondente e o arquivo executável * .exe não aparecerá como resultado da
compilação.

Consideremos o esquema funcional de um programa comum, um EA.

Veja diretamente no código:

35
Ambiente de Desenvolvimento do MT4
O ambiente de desenvolvimento (informação do MT4) não é um componente do programa. O
ambiente de informação é um conjunto de parâmetros disponíveis para serem processados por
um programa. Por exemplo, é o preço de segurança que vem com um novo tick, o volume
acumulado em cada novo tick, a informação sobre os preços máximos e mínimos das barras de
histórico, os parâmetros que caracterizam as condições de negociação oferecidas por um centro
de negociação e assim por diante. O ambiente de informação é sempre guardado e, a cada
nova marca, que é atualizado pelo terminal do cliente ligado ao servidor.

Estrutura do programa
36
Parte do cabeçalho

A parte do cabeçalho consiste das primeiras linhas no início de um programa, que contêm
informações gerais sobre o programa. Por exemplo, esta parte inclui linhas de declaração e
inicialização de variáveis globais. (A necessidade de incluir essa ou aquela informação na parte
do cabeçalho será discutido mais adiante).

Veja a imagem:

Funções especiais

A característica distintiva dos programas destinados à operação no terminal cliente MetaTrader


4 é o seu trabalho com informações constantemente atualizadas em tempo real. Na linguagem
MQL4, essa peculiaridade se reflete na forma das três funções especiais: OnInit(), OnTick() e
OnDeinit().

Normalmente, após a parte do cabeçalho, são descritas funções especiais. A descrição da


função especial parece a descrição de uma função definida pelo usuário, mas as funções
especiais têm nomes predefinidos: init(), start() ou OnTick() e deinit(). As funções
especiais são um bloco de cálculos e estão relacionadas ao ambiente de informação do terminal
cliente e às funções definidas pelo usuário. As funções especiais são descritas em detalhe
em Funções especiais .

A propriedade principal de todas as funções especiais é sua execução em um programa sob


certas condições sem usar uma chamada de função especial dentro do programa. Funções
especiais são chamadas para execução pelo terminal cliente. Se um programa contém a

37
descrição de uma função especial, ela será chamada (e executada) de acordo com as condições
de chamada (e suas próprias propriedades).

Função especial OnInit()

A propriedade distinta da função OnInit() é a sua execução na inicialização do programa. Se


um programa contém a descrição da função especial OnInit(), será chamado e executado no
momento em que o programa for iniciado. Se não houver nenhuma função OnInit() em um
programa, nenhuma ação será executada no início do programa.

Em EAs, OnInit() é chamado e executado após o terminal do cliente iniciar e carregar os


dados históricos, depois de alterar o período do gráfico, após a compilação do programa no
MetaEditor, depois de alterar quaisquer parâmetros de entrada da janela de configuração do
EA, e depois de alterar as contas.

Nos scripts , OnInit() também é chamado e executado imediatamente após ele ser anexado a
um gráfico.

Em indicadores personalizados , OnInit() é chamado e executado imediatamente após o


início do terminal do cliente, após alterar o período do gráfico, após a compilação do programa
no MetaEditor e depois de alterar quaisquer parâmetros de entrada da janela de configuração
do indicador personalizado.

Função especial OnTick()

As propriedades distintas da função especial OnTick() diferem dependendo do tipo de


programa executável.

Em EAs , OnTick() é chamado (e executado) imediatamente após um novo tick. Se um novo


tick surgiu durante a execução de OnTick(), este tick será ignorado, e OnTick() não será
chamado para execução até que um novo Tick seja recebido.

OBS: Tick é a mudança de preço que é mostrada no Gráfico. Cada novo preço, você deve
considerar que seja um novo Tick.

A possibilidade de chamar e executar OnTick() é influenciada pelo estado do botão


"Negociação Automatizada" estiver ativo. Botão disponível na plataforma MetaTrader 4
conforme imagem:

Se este botão estiver desabilitado, o terminal de cliente não chamará para execução
OnTick() independentemente de novas cotações vir ou não. No entanto, alterar o estado do
botão de habilitado para desabilitado não encerra a sessão de operação atual de OnTick().

38
O processamento da função OnTick() é concluído assim que todos os comandos que estão
dentro desta função for executada. É bom lembrar que ela é executada uma única vez na
inicialização do EA, script ou Indicador Personalizado.

Função especial OnDeinit()

A função especial OnDeinit() tem sua execução na terminação do programa. Se um programa


contém a função OnDeinit(), ele será chamado e executado no encerramento do programa. Se
um programa não contém a função OnDeinit(), nenhuma ação será executada no
encerramento do programa.

O terminal do cliente chama a OnDeinit() no encerramento do terminal, quando uma janela


Gráfica é fechada, antes de alterar um período de gráfico, e em uma nova compilação de
programa bem-sucedida no MetaEditor, ao alterar parâmetros de entrada e quando uma conta
é Alterada.

Em EAs e scripts , o encerramento do programa com a chamada necessária de OnDeinit()


pode acontecer ao anexar a um gráfico um novo programa do mesmo tipo que substitui o
anterior.

Em indicadores personalizados, OnDeinit() não é executado quando um novo indicador é


anexado a um gráfico. Vários indicadores podem operar em uma janela de segurança, por isso
a conexão de um novo indicador a um gráfico não resulta no desligamento de outros
indicadores com chamada OnDeinit().

O tempo de execução da função OnDeinit() é limitado a 2,5 segundos. Se o código da função


especial OnDeinit() for executado por mais tempo, o terminal do cliente terminará com força a
execução da função OnDeinit(), e a operação do programa.

Em resumo as funções são executadas sempre nesta sequencia:

1-OnInit()

2-OnTick()

3-OnDeinit()

39
Funções definidas pelo usuário

As funções definidas pelo usuário geralmente são dadas após a descrição de funções
especiais. O número de funções definidas pelo usuário em um programa é ilimitado. Na Figura
anterior, nosso exemplo contém apenas uma função definida pelo usuário, mas um programa
pode conter 10 ou 500, ou nenhum. Se nenhuma função definida pelo usuário for usada em um
programa, o programa terá uma estrutura simples: a parte do cabeçalho e a as funções
especiais.

Veja a imagem do Código com Funções definidas pelo Usuário:

40
Funções padrão

Como mencionado anteriormente, as funções padrão podem ser apresentadas apenas como
uma chamada de função. A descrição de uma função padrão está oculta do programador e,
portanto, não pode ser alterada. No entanto, ele está disponível para o MetaEditor. Durante
a compilação do programa, o MetaEditor formará um arquivo executável, no qual todas as
funções padrão chamadas serão executadas corretamente até o máximo.

Veja imagem de uma função padrão

41
Com base no que foi mostrado, você entende que para um programa ser compilado e começar
a ter funcionalidades, ele vai precisar do cabeçalho, funções especiais, e funções
padrões. Funções definidas pelo usuário, vai depender da sua criatividade.

Veja o escopo geral.

Nenhuma das funções pode ser criada dentro de outra função. É proibido.

Veja arranjos Corretos, note que a posição das funções não interfere. A única coisa que é
importante permanecer é o cabeçalho sempre no topo do código.

42
Seguem-se exemplos de arranjos incorretos para escrever funções.

Seqüência de execução do código

Cabeça e funções especiais

No momento em que um programa é iniciado em uma janela Gráfica, linhas contidas no


cabeçalho do programa são executadas.

Depois que as preparações descritas na parte do cabeçalho são feitas, o terminal do cliente
passa a controlar a função OnInit() especial, e essa função é executada (a passagem de
controle é mostrada no esquema estrutural em grandes setas amarelas mostrado
anteriormente). A função especial OnInit() é chamada e executada somente uma vez no início
da operação do programa. Esta função normalmente contém um código que deve ser
executado apenas uma vez antes da operação principal do programa ser iniciado.

Por exemplo, quando OnInit() é executado, algumas variáveis globais são inicializadas, objetos
gráficos são exibidos em uma janela de gráfico ou mensagens podem ser mostradas. Depois
que todas as linhas de programa em OnInit() são executadas, a função termina sua execução
e o controle é retornado ao terminal do cliente.

O tempo de operação do programa principal é o período de funcionamento da função OnInit()


especial.

Terminado todo o trabalho na OnInit(), assim que é feita a recepção de um novo tick pelo
terminal cliente a partir de um servidor, o terminal cliente chama a execução de OnTick(). Esta
função (como outras funções) pode se referir ao ambiente de informações do terminal do
cliente, realizar cálculos necessários, abrir e fechar ordens e em breve. Ou seja, ele pode
executar quaisquer ações permitidas pelo MQL4.

43
Quando OnTick() é executado, geralmente é produzida uma solução que é implementada
como uma ação de controle (veja as setas vermelhas na Figura anterior). Este controle pode ser
implementado como uma solicitação de negociação para abrir, fechar ou modificar uma ordem
formada pelo programa.

Depois que todo o código da função OnTick() especial do EA é executado, OnTick() termina
sua operação e retorna o controle para o terminal do cliente. O terminal segura o controle por
algum tempo, não começando nenhuma função especial. Aparece uma pausa durante a qual o
programa não funciona. Mais tarde, quando um novo sinal vem, o terminal cliente passa o
controle para OnTick() novamente, e como resultado, a função é executada novamente.

O processo é repetido enquanto o programa é anexado a um gráfico e pode continuar por


semanas e meses. Durante este período, um EA pode realizar negociação automatizada, ou
seja, pode implementar a sua atribuição principal. Na Figura anterior, a chamada repetida de
OnTick() é mostrada por várias setas amarelas envolvendo a função OnTick() especial.

Quando um comerciante remove um EA de um gráfico, o terminal cliente executa a função


OnDeinit() uma única vez. A execução dessa função é necessária para o encerramento correto
da operação de um EA. Durante a operação, um programa pode, por exemplo, criar objetos
gráficos e variáveis globais do terminal cliente. A função OnDeinit() pode conter código para
excluir objetos desnecessários e variáveis. Após a conclusão do OnDeinit(), o controle é
retornado ao terminal do cliente.

As funções especiais executadas podem se referir ao ambiente de informação (veja as finas


setas azuis na Figura abaixo) e chamar a execução de funções definidas pelo usuário (veja as
finas setas amarelas na Figura abaixo). Observe que as funções especiais são executadas após
serem chamadas pelo terminal cliente na ordem predefinida: inicia na OnInit(), depois
qualquer número de chamadas de OnTick() e depois OnDeinit(). As condições sob as quais o
terminal cliente chama funções especiais são descritas em Funções especiais .

44
Veja a imagem novamente:

Funções definidas pelo usuário

As funções definidas pelo usuário são executadas quando uma chamada para essa função está
contida em alguma outra função. Neste caso, o controle é passado oportunamente para a
função definida pelo usuário e, após a execução da função, o controle é retornado ao local da
chamada (veja as flechas finas de laranja na Figura acima). A chamada de funções definidas
pelo usuário pode ser contida não somente na descrição de uma função especial, mas também
na descrição de outras funções definidas pelo usuário. Uma função definida pelo usuário pode
chamar outras funções definidas pelo usuário. Isso é amplamente utilizado na programação.

As funções definidas pelo usuário não são chamadas para execução pelo terminal
cliente. Quaisquer funções definidas pelo usuário são executadas dentro da execução de uma
função especial que retorna o controle para o terminal do cliente. As funções definidas pelo
usuário também podem solicitar para usar os valores das variáveis do ambiente de informação
do terminal do cliente (veja as finas setas azuis na Figura acima).

45
Se um programa contém uma função definida pelo usuário, mas não há chamada dessa função,
essa função definida pelo usuário será excluída do programa pronto na fase de compilação e
não será usada no funcionamento do programa.

Execução do programa

As habilidades de programação são mais desenvolvidas se o programador tiver um programa de


funcionamento pequeno para fazer testes iniciais. Para entender todo o programa, é necessário
examinar minuciosamente todos os seus componentes e rastrear sua operação passo a
passo. Observe, propriedades de função especial de diferentes programas de aplicativo (EAs,
scripts, indicadores) são diferentes. Aqui vamos analisar como um EA opera.

Exemplo de um EA simples:

Este EA é composto de Cabeçalho, com algumas declarações veja a imagem:

46
Temos as declarações padrões como as #property e a variável Global int Count=0;

Nesta linha, a variável global Count é declarada e inicializada com um valor de zero.

Inclusive, essa variável pode ser utilizada em qualquer função do programa.

Logo a baixo temos a OnInit()

O corpo da função contém apenas dois operadores.

2.1 Function Alert() mostra uma janela de alerta: Acionada no inicio que o EA é ligado a um
Gráfico.

2.2 O retorno do operador finaliza o funcionamento do OnInit().

Como resultado da execução OnInit(), um alerta será gravado. A finalidade aqui é mostrar um
EA simple, em EAs mais complexos, vai ser raro encontrar um Alert() na função OnInit().

Na sequencia o Terminal detecta a presença de conteúdo na OnTick(), então essa função é


acionada.

Note que na função OnTick(), temos uma variável Price do tipo double, inicializada com o
preço de compra.

Bid é o preço de cotação de compra.

Temos também a variável global sendo incrementada com o sinal (++) que é a mesma coisa de
(Count=Count+1).

47
Em seguida temos a função padrão Alert() mostrando a variável Count e o novo Preço de
cotação.

Lembrando que a função OnTick() será acionada somente quando um novo Tick ocorrer.

Para finalizar temos a função OnDeinit()

Ela é chamada pelo terminal, quando removemos o EA do gráfico.

Neste exemplo foi feito somente uma chamada na função Alert();

Veja o resultado do EA quando ligado a um Gráfico, e na sequencia fazemos a exclusão do EA


do Gráfico.

A partir deste exemplo, você pode facilmente ver que um programa é executado de acordo com
as funções especiais e funções descritas dentro das funções especiais.

Terminar o programa, e iniciá-lo novamente. Tendo feito isso várias vezes, você terá
experiência usando seu primeiro programa. Vai funcionar tanto agora como da próxima
vez. Outros programas que você escreverá também serão construídos de acordo com a
estrutura descrita e, para iniciar sua execução, você também precisará anexá-la a um gráfico.

Se você entender todos os conceitos e regras, então o processo de criação de programas em


MQL4 será fácil e agradável.

Exemplo EA Envio de E-mail

48
Como regra são as mesmas, não vou descrever todos os passos novamente, os programas a
seguir segue o mesmo padrão nas sequência em que são chamadas para execução pelo
terminal cliente.

Ou seja, primeiro vai a descrição de OnInit(), então OnTick(), e a última é OnDeinit(). No


entanto, funções especiais são chamadas para execução pelo terminal cliente de acordo com
suas próprias propriedades. É por isso que a localização de uma descrição em um programa não
importa. Vamos mudar a ordem das descrições e ver o resultado.

Nosso próximo EA vai enviar 3 e-mail, sendo:

1. Primeiro e-mail na função OnInit()


2. Segundo e-mail na abertura de um novo Candle na função OnTick()
3. Terceiro e-mail quando o EA for Retirado do Gráfico na função OnDeinit()

Veja a imagem do código do EA:

Veja o resultado na caixa de E-mail:

49
Como disse anteriormente, não vou explicar novamente cada função, pois utilizamos as
mesmas funções do EA anterior.

Veja que recebemos os 3 e-mails conforme era planejado no código.

Para que seja possível o envio de e-mail pela plataforma ou pelo programa em
MQL4, você precisa fazer os seguintes passos a seguir:

1. Acesse o MataTrader4
2. Clique no Menu Ferramentas e na sequencia clique em Opções.
3. Clique na aba E-mail
4. Preencha os dados na tela a seguir:

Feita a configuração, clique em Testar, será mostrado a seguinte mensagem:

50
Clique em OK e depois feche a tela de opções clicando em OK.

Você consultara se o teste de envio de e-mail deu certo, consultado em Terminal na aba diário.

Veja a imagem:

É importante ressaltar que a base de um EA é as 3 funções Especiais.

Exemplo EA Envio de Notificação para Seu Celular Android ou iPhone

Aqui não iremos explicar novamente o uso das funções OnInit(), OnTick() e OnDeinit()

Vamos mostrar como é feito todo processo para envio das notificações.

Veja que o código abaixo esta fazendo exatamente o proposto nesse título, Enviamos 3
notificações utilizando a função SendNotification().

51
1.Primeira notificação é feita na função OnInit().

2.Segunda notificação é feita na função OnTick().

3.Terceira notificação é feita na função OnDeinit().

Veja a imagem abaixo as notificações no Celular:

52
Veja que recebemos os 3 notificações no Celular conforme era planejado no código.

Para que seja possível o envio de Notificações pela plataforma ou pelo programa em
MQL4, você precisa fazer os seguintes passos a seguir:

1. Acesse o MataTrader4
2. Clique no Menu Ferramentas e na sequencia clique em Opções.
3. Clique na aba Notificações
4. Preencha os dados na tela a seguir:

53
Preencha os dados Habilitar notificações via Push e Notificar Operações de
negociação. Informe o campo MetaQuotes ID: e clique em testar, depois novamente clique
em OK.

Para obter o MetaQuotes ID, você deve ter instalado o MetaTrader 4 no seu Celular Android
ou iPhone. Após instalado o Metatrader 4 você deve clicar no link MQID no topo da aplicação
no celular.

Veja a imagem a seguir:

Após te o MetaQuotes ID, digite esse numero no seu MetaTrader 4 e clique em OK.

Pronto, é bem simples, esse tipo de notificação serve tanto para EAs simples ou EAs complexos.

54
Operadores
Esta seção trata das regras de formatação e execução dos operadores usados no MQL4. Cada
seção inclui exemplos simples que demonstram a execução dos operadores. Para digerir o
material na íntegra, recomenda-se a criação real de um código e a compilação para que seja
visto na pratica a execução de todos exemplos. Isso também irá ajudá-lo a consolidar
habilidades em trabalhar com o MetaEditor.

Operador de Atribuição
O operador de atribuição é o operador mais simples e mais utilizado.

Operador de atribuição representa um registro que contém o caractere "=" (sinal de


igualdade). À esquerda deste sinal de igualdade especificamos o nome de uma variável, à
direita dela damos uma expressão. O operador de atribuição é terminado com ";" (ponto e
vírgula).

Variável = Expressão ;

Você pode distinguir o operador de atribuição de outras linhas no texto do programa pela
presença do sinal de igualdade. Você pode especificar como uma expressão: uma constante,
uma variável, uma chamada de função ou uma expressão como tal.

O operador de atribuição, como qualquer outro operador, é executável. Isso significa que o
registro que compõe o operador de atribuição é executado de acordo com a regra. Ao executar
o operador, o valor da parte direita é calculado e então atribuído à variável à esquerda do sinal
de igualdade. Como resultado da execução do operador de atribuição, a variável na parte
esquerda sempre toma um novo valor; Esse valor pode ser diferente ou igual ao valor anterior
da variável. A expressão na parte direita do operador de atribuição é calculada de acordo com a
ordem das operações.

Outros Exemplos de Operador de Atribuição

Em um operador de atribuição, é permitido declarar o tipo de uma variável à esquerda do sinal


de igualdade:

Int In = 3; // O valor constante é atribuído à variável Do


double Do = 2,0; // O valor constante é atribuído à variável Do
bool Bo = true; // O valor constante é atribuído à variável Bo
color Co = 0x008000; // O valor constante é atribuído à variável Co
string St = "sss"; // O valor da constante é atribuído à variável St
datetime Da = D ' 01.01.2004 ';// O valor constante é atribuído à variável Da

As variáveis declaradas anteriormente são usadas em um operador de atribuição sem


especificar seus tipos.

In = 7; // O valor constante é atribuído à variável In


Do = 23,5; // O valor constante é atribuído à variável Do
Bo = 0; // O valor constante é atribuído à variável Bo

55
Em um operador de atribuição, o tipo de uma variável não é permitido ser declarado na
parte direita do sinal de igualdade:

Em um operador de atribuição, o tipo de uma variável não pode ser repetidamente


declarado.

Exemplos de utilização das funções definidas pelo usuário e padrão na parte direita:

In = minha_funcao();// O valor da função definida pelo usuário é atribuído à


variável In
Do = funcao_2();// O valor da função definida pelo usuário é atribuído à
variável Do
Bo = IsConnected();// O valor da função padrão é atribuído à variável Bo
St = ObjectName(0);//O valor da função padrão é atribuído à variável St
Da = TimeCurrent();//O valor da função padrão é atribuído à variável Da

O exemplo de usar expressões na parte direita:

In=((( minha_funcao() + 100)/2)*3);// A variável In é atribuída com o valor da


expressão
Do = ((funcao_2()*3)/2);// A variável Do é atribuída com o valor de expressão

Exemplo de Operadores de Atribuição de Forma abreviada.

In = In / 33; // Forma padrão


In /= 33 ; // Forma abreviada do operador de atribuição

In = In * 33; // Forma Padrão


In *= 33 ; // Forma abreviada do operador de atribuição

In = In + 33; // Forma Padrão


In += 33 ; // Forma abreviada do operador de atribuição

In = In - 33; // Forma Padrão


In -= 33 ; // Forma abreviada do operador de atribuição

Verifique o programa EAFXTRADE_V04, toda implementação esta disponível nele. Conforme


imagem a seguir:

56
Operador condicional 'if - else'
Como regra, se você escrever um programa aplicativo, você precisa codificar várias soluções em
um programa. Para resolver essas tarefas, você pode usar o operador condicional 'if-else' em
seu código.

O operador de formato completo «if-else» contém um cabeçalho que inclui uma condição, e o
corpo 1, a palavra-chave «else» e o corpo 2. Os corpos do operador podem consistir em um ou
vários operadores; Os corpos são fechados em chaves.

57
If(Condição) // Cabeçalho do operador e condição
{
corpo 1 dos operadores // Se a condição for verdadeira, então ...
os operadores que compõem o corpo 1 são executados
}
else // Se a primeira condição não for atendida
{
Corpo 2 dos operadores são executados;
}

Exemplo 1
Este é um exemplo simples, vou mostrar em código alguns exemplo do Operador if-else

Verifique o código no programa EAFXTRADE_V05

Ao Anexar o EA no gráfico de 1 Minuto, e esperar a mudança de Candle, Obtemos o seguinte


resultado:

58
Exemplo 2
Vou mostrar outro exemplo de if-else

A diferença neste outro exemplo, é que utilizamos um if-else um pouco diferente.

OBS: Lembre que && é operador Booleano.

Exemplo: if ((Open[1] > Media_periodo_20)&&(Close[1] < Media_periodo_20))

Para que a condição a cima seja verdadeira então a parte em verde da expressão tem que ser
verdadeira e a parte cinza também tem que ser verdadeira. Em resumo, dentro desta condição
esta sendo feito 2 testes e os dois tem que ser verdadeiros para que o programa passe pelo
BLOCO 1. E esse mesmo processo se repete na condição 2.

Primeiro temos um if para resolver o BLOCO 1 e no else temos outro if para resolver o
BLOCO 2.

59
Significa que para executar o BLOCO 1, a condição 1 deve ser atendida. Caso a condição 1
não seja atendida, o programa passara pela condição 2.

Se a condição 2 for atendida, ai sim o BLOCO 2 será executado.

Neste exemplo o BLOCO 1 ou o BLOCO 2 só serão executados se uma das condições forem
atendida.

Veja o código do programa a seguir:

Veja o programa EAFXTRADE_V06. Execute o no seu computador e veja o resultado.

60
Exemplo 3

A diferença deste exemplo, com o exemplo 2, é que utilizamos um if-else de forma um pouco
diferente.

Primeiro temos um if para resolver o BLOCO 1 e no else BLOCO 2 temos outro if para ser
executado.

Significa que para executar o BLOCO 1, a condição 1 deve ser atendida. Caso a condição 1
não seja atendida, o programa passara para o BLOCO 2.

Se a condição 2 dentro do BLOCO 2 for atendida, ai sim o Alerta será executado.

Neste exemplo o BLOCO 1 só será executado se a condição 1 for atendida, caso contrario o
programa passara pelo BLOCO 2.

É importante mostrar esse tipo de exemplo, para que você veja a variedade de formas que será
possível de ser criada com o operador if-else

Veja o código do programa a seguir:

61
Veja o programa EAFXTRADE_V07. Execute o no seu computador e veja o resultado.

Exemplo 4

Vamos um exemplo um pouco mais complexo, onde usaremos if-else dentro de outro if-else

Foi criado uma função com o nome analise_tendencia_MEDIA_200_72(int BUY_SELL),


essa função recebe um parâmetro de entrada qe é do tipo (OP_BUY ou OP_SELL) , esses
sinais representam Compra e Venda no Metatrader 4.

Dentro desta função criamos o primeiro if-else, onde é testado se eu quero comprar ou
vender.

Exemplo: if(BUY_SELL == OP_SELL) else if(BUY_SELL == OP_BUY)

Se eu passar o parâmetro OP_SELL para a função analise_tendencia_MEDIA_200_72,

Exemplo: analise_tendencia_MEDIA_200_72(OP_BUY)

62
Significa que nesse caso a condição 1 não seria atendida, então a execução do programa
passaria para testar a condição 2 sendo que ela é justamente a condição que eu solicitei.

Nesse caso a execução do programa continua, porem entrando no BLOCO 2

Assim que a execução entra no BLOCO 2, um novo if esta para testar uma nova condição.

Exemplo: if((Open[1] < Media200) &&(Close[1] > Media200))

Essa condição significa o seguinte:

Se o candle anterior abriu com o preço menor que o preço da media 200 e se o candle anterior
teve o preço de fechamento maior que o preço da media 200, então a função retorna
verdadeiro. Isso significa que o alerta “Alert("Sinal de Compra", "Veja Possibilidade de
Compra");” vai ser acionado. Devido o retorno da função analise_tendencia_MEDIA_200_72 ter
retornado verdadeiro para um sinal de compra

Veja imagem do programa:

63
Veja o programa EAFXTRADE_V08. Execute o no seu computador e veja o resultado.

Exemplo 5

Aqui vou simplesmente mostrar uma imagem de uma função utilizada por um de meus robôs,
ela é responsável em abrir ordens de compra e de venda.

Estou mostrando ela, para que você veja o nível de desenvolvimento que irei ensinar a vocês
mais a frente.

Veja imagem:

64
Note que fazemos analise de medias, analise de suporte e resistência e outras analises.

Mais a frente vou ensinar a vocês a programação mais complexas.

Operador while e for


A funcionalidade mais poderosa do MQL4 é a possibilidade de organizar ciclos (loops).

Ao criar programas de aplicação, você pode frequentemente usar os cálculos repetidos, que são
na maior parte as linhas repetidas do programa. Para tornar a programação confortável e o
programa em si fácil de usar, usamos operadores de ciclo. Existem dois operadores de ciclo em
MQL4: While e for. Consideraremos o primeiro nesta seção.

Operador while

O operador while consiste no cabeçalho que contém uma condição e o corpo do ciclo
executável encerrado entre chaves.

65
Código disponível no programa EAFXTRADE_V09

Esse programa faz algo bem simples, ele simplesmente mostra um alerta 10 vezes, pois foi o
tanto de vezes que eu estipulei para o while ficar no ciclo.

Significa que enquanto a variável contador for menor ou igual a 10, ele vai repetir o processo
novamente.

A estrutura básica do while é essa, o que pode mudar é a condição que pode ser ou não mais
complexa e a codificação dentro do loop.

While ele vai ser muito utilizado em nossos EAs, pois podemos percorrer períodos no gráfico
atrás de topos e fundos, cálculo de preços, e outras analises. Portanto é bom treinar bastante
essa parte.

Primeiro teste, vamos descrever brevemente o coeficiente de Fibonacci. O matemático italiano,


Leonardo Fibonacci, descobriu uma seqüência única de números:

A função dos Loops na programação é facilitar o acesso a dados e cálculos, note que com
pouco mais de 6 linhas o while resolveu uma conta complexa.

Veja o código do programa abaixo:

66
Veja o código no programa EAFXTRADE_V10

Abaixo tem explicações sobre a função Fibonacci.

67
Deve ser particularmente observado o seguinte:

Looping é uma execução continuamente repetida de operadores que compõem


o corpo do ciclo. É uma situação crítica que resulta da realização de um algoritmo errado.

Uma vez que ocorre um loop, o programa executa indefinidamente o bloco de operadores que
compõem o corpo do ciclo.

Abaixo está um exemplo simples de um operador de ciclo em loop 'while' que você nunca
deve fazer:

No exemplo acima, os valores da variável i são acumulados (incrementados) em cada iteração.

Como resultado, a condição nunca se tornará falsa. Uma situação semelhante ocorre, se nada é
calculado no corpo do ciclo em tudo. Por exemplo, no seguinte código:

68
Em ambos os casos acima, este processo se repetirá sem parar. Depois de ter entrado na
armadilha de um código em loop, o controle não pode deixá-lo mais. Esta situação é
particularmente perigosa na negociação Expert Advisors e scripts. Em tais casos, as
variáveis de ambiente geralmente não são atualizadas, uma vez que a função especial não
completa sua operação, enquanto o comerciante pode não ter conhecimento do loop
existente. Como resultado, o controlo no programa de execução não pode ser passado para as
linhas de programas correspondentes onde é tomada a decisão de abrir ou fechar ordens.

O programador deve evitar tais condições, nas quais um loop não controlado torna-se
possível. Não há nenhuma técnica que ajudaria a descobrir esta situação, nem na compilação
do programa nem na sua execução. O único método possível para detectar tais erros
algorítmicos é exame atento de seu código - raciocínio lógico e senso comum.

Operador for

O operador de ciclo de formato completo 'for' consiste no cabeçalho que contém Expressão 1,
Condição e Expressão 2 e do corpo do ciclo executável incluído entre chaves.

for (Expressão 1; Condição; Expressão 2) // cabeçalho do operador


{ // Abertura do Loop
bloco de operadores // corpo do ciclo
compondo o ciclo
} //fechando o ciclo

O programa a seguir faz a somatória de números inteiros de 1 a 10, a solução será


1+2+3+4+5+6+7+8+9+10 = 55.

Note que as variáveis Nom_1 = 1 e Nom_2 =10, neste caso ele fara a somatória de 1 a 10.

Depois quero que você teste mudando Nom_1 = 20 e Nom_2 = 38 e veja o resultado.

69
Veja que o for possibilita percorrer 2,10,100,1000... números com o mesmo código.

Para testar outros valores, basta você acessar o programa EAFXTRADE_V11 e mudar os valores
das variáveis Nom_1 e Nom_2.

Vou mostrar um outro exemplo, onde é feito o mesmo calculo, porem de traz para frente.

Veja a imagem a seguir:

70
Veja o código no programa EAFXTRADE_V12

Próximo exemplo eu mostro a você como ler o histórico de ordens que você já negociou.

Veja:

71
Acesse o programa EAFXTRADE_13, faça o teste no seu computador para você ver o resultado.

Os exemplos mostrados acima é para mostrar varias formas de utilizar o operador for.

É muito importante que você treine escreva códigos pequenos, com as funções já ensinadas
até agora.

Caso tenha duvida, não deixe de acessar os códigos disponíveis neste curso, garanto que vai te
ajudar muito.

Operador break
Em alguns casos, por exemplo, ao programar algumas operações de Loop, pode ser necessário
quebrar a execução de um Loop antes que sua condição se torne falsa. Para resolver tais
problemas, você deve usar o operador break.

72
O operador "break" consiste em apenas uma palavra e termina em caráter ";”.

Peguei uma parte do código do ultimo exemplo, e nesse caso o break é acionado caso não
tenha localizado nenhum registro.

O "break" interrompe a execução do operador externo mais próximo do tipo 'while', 'for' ou
'switch'. A execução do "break" do operador consiste em passar o controle para fora do
operador composto do tipo "while", "for" ou "switch" para o operador seguinte mais
próximo. A interrupção do operador só pode ser utilizada para interrupção da execução dos
operadores listados acima.

Vamos criar um programa onde a função dele é simplesmente contar de 1 a 100, porem
quando a execução do programa chegar em 49 ele vai parar através do break

73
Veja o programa inteiro no EAFXTRADE_V15.

Vamos fazer um outro exemplo parecido usando while.

Veja o programa inteiro no EAFXTRADE_V16.

O próximo exemplo é utilizando o operador switch.

74
Veja o programa inteiro no EAFXTRADE_V17.

Resumindo o Operador break, sempre será utilizado em algum tipo de situação parecido com as
situações mostrada nos exemplos acima.

Em outros casos ele pode ser a única porta de saída de um LOOP, isso significa que o LOOP só
será encerrado se certa condição acontecer e o break for acionado.

Durante o curso faremos todos os exemplos do livro e mais outros exemplos com mais
complexidade na pratica, para que você realmente entenda o uso de cada operador.

Operador Continue

75
Às vezes, quando você usa um LOOP no código como mostrado anteriormente, é necessário
encerrar o processamento da iteração atual e ir para o próximo passo sem executar os
operadores restantes que compõem o corpo do ciclo. Nesses casos, você deve usar o operador
continue.

O operador continue consiste em uma palavra e termina em ";" (ponto e vírgula).

Vamos ver o seguinte programa, onde temos 2 contas, sendo que uma das contas, tem 100
USD de saldo, enquanto a segunda conta tem 0 USD.

A função deste programa é rentabilizar o saldo da conta 1 com 1% ao dia e sempre que o saldo
da conta 1 for maior que o limite para transferência 130 USD, eu tenho que transferir 10% da
conta 1 para conta 2, até que eu consiga atingir o saldo de 100 USD na conta 2

Veja o programa:

Veja programa completo em EAFXTRADE_V18

Note que sempre que a execução chega no operador continue, o código circulado de vermelho
é ignorado, e a execução do LOOP externo continua a ser executado.

O código marcado de vermelho só será executado, quando a condição abaixo for FALSA

if (primeira_conta < Limite_maximo_primeira_conta)

Se o saldo da primeira conta for MAIOR ou IGUAL o


LIMITE_MAXIMO_PRIMEIRA_CONTA, o programa vai executar o bloco marcado em
vermelho.

76
Com base no exemplo a cima, é importante você treinar, criar mais exemplo, para que você
realmente entenda o uso do operador continue.

Operador switch
Alguns programas implicam ramificação de seu algoritmo em várias variações. Em tais casos, é
muito conveniente usar o operador 'switch', especialmente se houver dezenas ou centenas de
variações, enquanto o código 'if' se torna inchado se você usar muitos operadores aninhados.

O operador 'switch' consiste no cabeçalho e no corpo executável. O cabeçalho contém o nome


do operador e uma Expressão entre parênteses. O corpo do operador contém uma ou várias
variações 'case' e uma variação 'default'.

Cada "caso" consiste na palavra-chave "case", uma constante,":" (dois pontos) e


operadores. A quantidade de variações 'case' não é limitada.

A variação 'default' consiste na palavra-chave 'default', ':' (dois pontos) e operadores. A


variação 'default' é especificada no corpo do operador 'switch' como a última, mas também
pode ser localizada em qualquer lugar dentro do corpo do operador ou mesmo estar ausente.

Os valores de Expressão e de Parâmetros só podem ser os valores de tipo int . A Expressão


pode ser uma constante, uma variável, uma chamada de função ou uma expressão. Cada
"case" de variação pode ser marcado por uma constante de número inteiro, uma constante
de caractere ou uma expressão constante. Uma expressão constante não pode incluir variáveis
ou chamadas de função.

Vou exemplificar com um exemplo mostrado anteriormente

Veja programa inteiro EAFXTRADE_V17

A estrutura do switch é conforme mostrado acima, o que vai poder mudar é a expressão e as
variações “case”.

77
Veja outro exemplo, porem não utiliza o break e é feito uma chamada a função;

O problema de não se utilizar o operador break, é que ele executara sempre a partir do numero
inteiro passado na expressão do operador switch.

Veja programa completo em EAFXTRADE_V19

Note que este exemplo já é um pouquinho mais complexo, pois no “case”, faço chamada a
função “verifica_valores_candle”, que na sequencia faz chamada a função
“verifica_media”. inclusive neste exemplo não utilizamos o variação 'default' no final.

O nível de complexidade vai depender da sua criatividade.

Vamos ver outro exemplo onde eu optei em escrever o código dentro de cada “case”

78
Desta vez estou utilizando break, pois quero que meu alerta mostre somente o que esta sendo
passado como parâmetro no swith, que nesse caso é 1 ou 2:

Veja programa completo em EAFXTRADE_V20

Veja outro exemplo:

79
Veja programa completo em EAFXTRADE_V21

Veja o resultado na tela de Alerta.

80
Ao contrário do algoritmo realizado no programa anterior, neste, não estamos usando o
operador 'break' em cada variação 'case'. Portanto, se o valor da Expressão for igual ao valor
de uma das Constantes, todos os operadores serão executados a partir dos operadores da
correspondente variação 'case'.

Veja que usamos o 'break' do operador na última variação 'case' para outro propósito: evitar
que os operadores correspondentes à variação 'default' sejam executados. Se não houver
valor igual à Expressão, o controle será passado para o operador que corresponde ao rótulo
default.

Assim, se o valor da variável predefinida não está dentro do intervalo de valores de 1 a 10, será
mostrado a mensagem de “Número errado inserido”.

OBS: não se usa expressão booleana(true ou False) pois o retorno desses operadores são
respectivamente 1 para True e 0 para False;

Chamada de função
Uma chamada de função já fizemos em vários exemplos, e imagino que você já tenha
ambientado com esse procedimento.

Basicamente uma chamada de função consiste no nome da função e na lista dos parâmetros
passados entre parênteses, algumas funções são somente para execução de códigos, outras
são para retorno de valores, mas a chamada sempre será da mesma forma.

Veja exemplo:

81
Outro exemplo:

Exemplo chamada a função padrão:

Função com retorno de valor:

Chamada de função se resume a isso, os exemplos mostrados a cima, mostra claramente como
é feito uma chamada a uma função. A diferença que vai ter de uma chamada para outra, é se a
função ter parâmetros de entrada e se a função retorna algum valor. O importante é você saber
que chamada de função sempre é feita dessa forma.

Quase todos os códigos que foram implementados neste livro, tem chama de função, é
interessante você acessar os exemplos e praticar para você entender a fundo essa parte.

Para finalizar esta parte, vou mostrar a forma de se escrever uma função, veja os dois
exemplos abaixo:

82
Exemplo 1:

Exemplo 2

83
Variáveis
Para criar programas em qualquer linguagem algorítmica saber diferentes tipos de variáveis é
muito importante. Nesta seção analisaremos todos os tipos de variáveis utilizadas no MQL4.

Variáveis predefinidas e função RefreshRates()


Existem variáveis com nomes predefinidos na linguagem MQL4.

Variável predefinida é uma variável com um nome predefinido, cujo valor é definido por um
terminal de cliente e não pode ser alterado por métodos de programa. Variáveis predefinidas
refletem o estado de um gráfico atual no momento do início do programa (Expert Advisor,
script ou indicador personalizado) ou como resultado da implementação RefreshRates ().

Lista de Nomes Predefinidos Simples de Variáveis


Ask - último preço de venda conhecido de um título atual;
Bid - último preço de compra conhecido de um título atual;
Bars - número de barras em um gráfico atual;
Point - ponto de um título corrente na moeda de cotação;
Digits - número de dígitos após um ponto decimal no preço de um título atual.

Lista de nomes predefinidos de matrizes-Timeseries


Time - tempo de abertura de cada barra no gráfico atual;
Open - Preço de abertura de cada barra no gráfico atual;
Close - preço de fechamento de cada barra no gráfico atual;
High - preço máximo de cada barra no gráfico atual;
Low - preço mínimo de cada barra no gráfico atual;
Volume - volume negociado em cada barra no gráfico atual.

Falamos Matrizes pois utilizamos “[0], [1], [2], [3], ...etc” na frete de cada variável.

Exemplo: Time[0] ou Time[1] ou Time[1000], não tem limite.

Veremos mais em tipos de variáveis

Propriedades de variáveis pré-definidas


O nome da variável predefinida não pode ser usado para identificar variáveis definidas pelo
usuário. Variáveis predefinidas podem ser usadas em expressões igualmente com outras
variáveis de acordo com as mesmas regras, mas o valor de uma variável pré-definida não pode
ser alterado. Ao tentar compilar um programa contendo um operador de atribuição, no qual
uma variável predefinida é colocada à direita de um sinal de igualdade, o MetaEditor mostrará
uma mensagem de erro. Em termos de visibilidade, as variáveis predefinidas referem-se a
global, ou seja, estão disponíveis a partir de qualquer parte do programa.

A propriedade mais importante de variáveis predefinidas é a seguinte:

84
Os valores de todas as variáveis predefinidas são atualizados automaticamente por um terminal
cliente no momento em que são iniciadas funções especiais para execução.

Os valores anteriores e atuais de variáveis predefinidas podem ser iguais, mas o próprio valor
será atualizado. No momento de uma função especial, os valores iniciais dessas variáveis já
estão atualizados e estão disponíveis nas primeiras linhas do programa.

Veja programa EAFXTRADE_V22

Iniciando este programa é fácil ver que os valores da variável Bid exibidos nos alertas serão
iguais ao preço atua. Da mesma forma você pode verificar valores de outras variáveis
dependendo das condições atuais. Por exemplo, a variável Ask também depende do preço
atual. O valor da variável Bars também será alterado se o número de barras mudar. Isso pode
acontecer em uma marca, em que uma nova barra é formada em uma janela de gráfico. O
valor de Point depende de uma especificação de segurança. Por exemplo, para EUR / USD este
valor é 0.0001, para USD / JPY é 0.01. O valor dos dígitos para esses títulos é igual a 4 e 2,
respectivamente.

Aqui está outra propriedade importante de variáveis predefinidas:

O terminal cliente cria um conjunto de cópias locais de variáveis predefinidas separadamente


para cada programa iniciado. Cada programa iniciado funciona com os seus próprios conjuntos
de cópias de dados históricos.

Em um terminal cliente, vários programas aplicativos (Expert Advisors, scripts,


indicadores) podem ser executados ao mesmo tempo, e para cada um deles o terminal cliente
criará um conjunto separado de cópias de todos os valores das variáveis predefinidas - dados
históricos. Vamos analisar em detalhes as razões para essa necessidade. A figura abaixo mostra
a possível operação de Expert Advisors com diferentes comprimentos de execução da função
especial OnInit(). Por razões de simplicidade, vamos supor que, nos Analistas Especialistas
analisados, não existem outras funções especiais e que ambos os Consultores Especialistas
operam nos mesmos prazos da mesma segurança.

85
Expert Advisors diferem no momento da execução OnTick(). Para os Expert Advisors simples o
nível médio, é aproximadamente igual a 1 até 100 milissegundos. Outros Expert Advisors
podem ser executados por muito mais tempo, por exemplo, vários segundos ou dezenas de
segundos. O intervalo de tempo entre carrapatos também é diferente: de vários milissegundos
a minutos e às vezes até dezenas de minutos. Vamos analisar no exemplo dado como a
frequência do recebimento de Ticks influencia a operação do Expert Advisor 1 e do Expert
Advisor 2 que têm tempo de execução OnTick() diferente.

No instante t0 Expert Advisor 1 está ligado a um terminal cliente e muda para o modo tick-
waiting. No momento t1 um tick vem e o terminal inicia a função especial OnTick
(). Juntamente com isso, o programa obtém acesso ao conjunto atualizado de cópias de
variáveis predefinidas. Durante a execução, o programa pode se referir a esses valores, eles
permanecerão inalterados dentro do tempo de operação OnTick(). Depois que o OnTick()
terminar sua operação, o programa entrará no modo tick-waiting.

O evento mais próximo no qual variáveis predefinidas podem obter novos valores é um novo
tick. O tempo de execução T1 do Expert Advisor 1 é consideravelmente mais curto do que um
tempo de espera entre carrapatos, por exemplo, o intervalo t 1 - t 2 ou t 2 - t 3, etc. Assim,
durante o período de execução do Expert Advisor 1 analisado há Nenhuma situação na qual
valores de variáveis predefinidas possam tornar-se velhos, ou seja, diferem valores verdadeiros
(do último conhecido) do momento atual.

Na operação do Expert Advisor 2 há outra situação, porque o seu OnTick() período de execução
T2 às vezes excede o intervalo entre Ticks. A função OnTick() do Expert Advisor 2 também é
iniciada no momento t 1. A figura acima mostra que o intervalo t 1 - t 2 entre Ticks é maior do
que o tempo de execução do OnTick() T2, por isso durante este período de operação do
programa as variáveis predefinidas não são atualizadas (nesse período os novos valores não
vêm de um servidor, Seus valores verdadeiros devem ser considerados valores que apareceram
no momento t 1).

Próxima vez que o início do Expert Advisor 2 é iniciado no momento t 2 quando o segundo tick
é recebido. Juntamente com esse conjunto de cópias de valores predefinidos também é
atualizado. Na figura acima vemos que o momento de t 3 tick coming está dentro do período
em que OnTick() ainda está sendo executado. Uma pergunta surge: quais serão os valores de
variáveis predefinidas disponíveis para o Expert Advisor 2 no período de t 3 quando o terceiro
tick chegar a t 32 quando OnTick() terminar sua operação? A resposta pode ser encontrada de
acordo com a seguinte regra:

86
Valores de cópias de variáveis predefinidas são salvos durante todo o período de funcionamento
das funções especiais. Esses valores podem ser atualizados à força usando a função padrão
RefreshRates().

Assim, se a função RefreshRates() não tiver sido executado) durante todo o período de
execução do OnTick, o Expert Advisor 2 terá acesso ao conjunto de cópias locais de variáveis
predefinidas que foi criado quando o segundo tick foi recebido. Embora os Consultores
Especialistas operem nas mesmas janelas, a partir do momento do recebimento do t 3, cada EA
operará com valores diferentes de variáveis predefinidas. O Expert Advisor 1 trabalhará com seu
próprio conjunto de cópias locais de dados históricos, cujos valores são definidos no momento t
3, e o Expert Advisor 2 trabalhará com suas próprias cópias de dados, cujos valores são iguais a
t 2.

Quanto maior o tempo de execução do programa aplicativo e quanto menor o intervalo entre
Ticks, maior a probabilidade de que o próximo Tick venha durante o período de execução do
programa. O conjunto de cópias locais de dados históricos fornece condições para cada
programa que garantem a constância de variáveis pré-definidas durante todo o tempo de
execução de uma função especial.

A partir do momento t 4, quando o próximo Tick chega, ambos EAs serão reiniciados, cada um
deles tendo acesso ao seu próprio conjunto de cópias de variáveis predefinidas, cujos valores
são formados no momento t 4 quando o quarto tick vem.

Função RefreshRates ()
bool RefreshRates()

Exemplo:

87
A função padrão RefreshRates() permite atualizar valores de cópias de dados históricos
locais. Em outras palavras, essa função atualiza os dados referente a um mercado atual
(Volume, tempo do servidor da última cotação, Bid, Ask, etc.) Esta função pode ser usada
quando um programa realiza cálculos por um longo período de tempo e Precisa de dados
atualizados.

RefreshRates() retorna TRUE, se no momento de sua execução há informações sobre novos


dados históricos no terminal (ou seja, se um novo tick surgiu durante a execução do
programa). Nesse caso, o conjunto de cópias locais de variáveis predefinidas será atualizado.

RefreshRates() retorna FALSE, se a partir do momento de uma execução de função especial


iniciar dados históricos no terminal do cliente não foram atualizados. Nesse caso, as cópias
locais de variáveis predefinidas não mudam.

Tenha em atenção que RefreshRates() influencia apenas no programa no qual é iniciado (não
influencia em todos os programas que funcionam num terminal de cliente ao mesmo tempo).

Significa que cada programa é responsável por sua chamada a função RefreshRates().

veja o exemplo a seguir, onde contamos o número de interações que um operador de ciclo
pode executar entre os Ticks.

Veja o programa EAFXTRADE_V23

Veja o resultado da execução do programa.

88
Veja que pode ter milhões de interações entre os Ticks.

Tipos de Variáveis
Um programa aplicativo em MQL4 pode conter dezenas e centenas de variáveis. Uma
propriedade muito importante de cada variável é a possibilidade de usar seu valor em um
programa. A limitação desta possibilidade está relacionada com o escopo variável.

Escopo de variável é um local em um programa onde o valor da variável está disponível. Cada
variável tem seu escopo. De acordo com o escopo, existem dois tipos de variáveis no MQL4:
local e global.

Variáveis locais e globais

Variável local é uma variável declarada dentro de uma função. O escopo das variáveis locais é
dentro do corpo da função, no qual a variável é declarada. Variável local pode ser inicializada
por uma constante ou uma expressão correspondente ao seu tipo.

Variável global é uma variável declarada fora de todas as funções. O escopo das variáveis
globais é todo o programa. Uma variável global pode ser inicializada apenas por uma constante
correspondente ao seu tipo (e não expressão). As variáveis globais são inicializadas apenas uma
vez antes de iniciar sua execução.

Se o controle em um programa estiver dentro de uma determinada função, os valores das


variáveis locais declaradas em uma função não estarão disponíveis em outras funções. O valor
de qualquer variável global está disponível para qualquer função, independente se ela é
especial ou definidas pelo usuário.

Exemplo variável local:

89
Veja programa EAFXTRADE_V24

Agora veja outro exemplo onde a variável é declarada de forma Global:

Com base nos exemplos acima, você já sabe o que é uma variável GLOBAL e uma variável
LOCAL

Variáveis estáticas

No nível físico, as variáveis locais são apresentadas numa parte de memória temporária de uma
função correspondente. Existe uma maneira de localizar uma variável declarada dentro de uma

90
função em uma memória de programa permanente, basta utilizar o modificador 'static'
indicado antes de um tipo de variável durante sua declaração:

Exemplo:

Veja programa EAFXTRADE_V26

As variáveis estáticas são inicializadas uma vez. Cada variável estática pode ser inicializada por
uma constante correspondente (como distinta de uma variável local simples que pode ser
inicializada por qualquer expressão). Se não houver inicialização explícita, uma variável estática
é inicializada por zero. Variáveis estáticas são armazenadas em uma parte de memória
permanente, seus valores não são perdidos ao sair de uma função. No entanto, as variáveis
estáticas têm limitações típicas de variáveis locais - o escopo da variável é a função, dentro da
qual a variável é declarada, distinta das variáveis globais cujos valores estão disponíveis em
qualquer parte do programa.

Você vê, que o programa EAFXTRADE_V26 tem o mesmo resultado do programa


EAFXTRADE_V25.

Variáveis externas

Variável externa é uma variável, cujo valor está disponível a partir de uma janela de
propriedades do programa. Uma variável externa é declarada fora de todas as funções e é
global - seu escopo é todo o programa. Ao declarar uma variável externa, o modificador 'extern'
deve ser indicado antes de seu tipo de valor:

As variáveis externas são especificadas na parte do cabeçalho do programa, ou seja, antes de


qualquer função. O uso de variáveis externas é muito conveniente se for necessário de vez em
quando para iniciar um programa com outros valores de variáveis.(mais conhecidos como
parâmetros de Entrada).

Veja o Exemplo:

91
Veja programa EAFXTRADE_V27

Valores de variáveis externas estão disponíveis a partir de uma janela de parâmetros do


programa. O interessante dessas variáveis é que elas podem ser alteradas a qualquer momento
- na fase de anexar o programa a uma janela gráfica e durante a operação do programa.

Veja a imagem:

92
No momento de anexar o programa a uma janela de Gráfico, os valores das variáveis contidos
no código do programa serão indicados em uma janela de parâmetros do programa. Um
usuário pode alterar esses valores. A partir do momento em que um usuário clica em OK, o
programa será iniciado pelo terminal do cliente. Os valores das variáveis externas serão aqueles
indicados por um usuário. No processo de operação, esses valores podem ser alterados pelo
programa executado.

Se um usuário precisar alterar valores de variáveis externas durante a operação do programa, a


janela de configuração deve ser aberta e as alterações devem ser feitas. Deve ser lembrado
que a barra de ferramentas de propriedades do programa pode ser aberta somente no período
em que o programa (Expert Advisor ou indicador) está aguardando uma nova marca, ou seja,
nenhuma das funções especiais é executada. Durante o período de execução do programa, esta
barra não pode ser aberta. É por isso que se um programa é escrito assim, que é executado
longo tempo (vários segundos ou dezenas de segundos), um usuário pode ter dificuldades em
tentar acessar a janela de parâmetros. Valores de variáveis externas de scripts estão
disponíveis apenas no momento de anexar o programa a um gráfico, mas não podem ser
alterados durante a operação. Se a janela de parâmetros estiver aberta, o Expert Advisor não
funcionará.

Exemplo de como alterar o parâmetros;

1. Clique com botão direito do mouse sobre a janela gráfica.


2. Corra o mouse até Expert Advisors(Robôs)
3. Clique em Propriedades.

Não há limite para criação de Variáveis Externas.

GlobalVariables

93
Vários programas de aplicação podem operar no terminal do cliente ao mesmo tempo. Em
alguns casos a necessidade pode ocorrer para passar alguns dados de um programa para
outro. Especialmente para este MQL4 tem variáveis globais do terminal do cliente.

A variável global do Client Terminal é uma variável cujo valor está disponível em todos os
programas de aplicação iniciados em um terminal cliente (forma abreviada: GV).

Nota, variável global do terminal do cliente e variável global são variáveis diferentes
com nomes semelhantes. O escopo de variáveis globais é um programa, no qual a variável é
declarada; Enquanto o escopo de variáveis globais do terminal do cliente é todos os
programas lançados no terminal do cliente.

Propriedades de GlobalVariables

Como diferente de outras variáveis, GV pode ser criada não somente de qualquer programa,
mas também suprimido. O valor GV é armazenado em um disco rígido e salvo depois que um
terminal cliente é fechado. Uma vez que o GV declarado existe no terminal cliente por 4
semanas a partir do momento da última chamada. Se durante este período nenhum dos
programas chamou essa variável, ele é excluído pelo terminal do cliente. GV pode ser apenas
do tipo double.

Funções para trabalhar com GlobalVariables

Há um conjunto de funções em MQL4 para trabalhar com GV (mostraremos mais a frente mais
conteúdo sobre GlobalVariables ). Vamos analisar os que serão usados em outros exemplos.

Função GlobalVariableSet()

Datetime GlobalVariableSet(string name , double value)

Esta função configura um novo valor de uma variável global. Se uma variável não existir, o
sistema cria uma nova variável global. No caso de uma execução bem-sucedida, a função
retorna a hora do último acesso, caso contrário, 0. Para obter uma informação de erro, a
função GetLastError() deve ser chamada.

Parâmetros:

Name - Nome de uma variável global.


Value - Novo valor numérico.

Função GlobalVariableGet()

double double GlobalVariableGet( string name )

94
A função retorna o valor de uma variável global existente ou, em caso de erro, retorna 0. Para
obter uma informação de erro, a função GetLastError() deve ser chamada.

Parâmetros:

Name - Nome de uma variável global.

Função GlobalVariableDel()

bool GlobalVariableDel( string de nome )

Esta função exclui uma variável global. No caso de uma exclusão bem-sucedida a função
retorna TRUE, caso contrário - FALSE. Para obter uma informação de erro, a função
GetLastError() deve ser chamada.

Parâmetros:

Name - Nome de uma variável global.

Para mostrar a conveniência e benefício de usar GlobalVariables, vamos criar um exemplo


para você entender melhor todo o processo.

Veja o programa a seguir:

95
Veja programa completo em EAFXTRADE_V28

96
Agora você vai pegar este programa, faça a instalação dele no seu MetaTrader. Em seguida
anexe ele em 3, 4 ou 5 gráficos, veja como a variável Experts se torna acessível para todos,
assim sendo possível ratear o dinheiro entre os gráficos.

ATENÇÃO: Nota, variável global do terminal do cliente e variável global são variáveis
diferentes com nomes semelhantes. O escopo de variáveis globais é um programa, no qual a
variável é declarada; Enquanto o escopo de variáveis globais do terminal do cliente é
todos os programas lançados no terminal do cliente.

Resultado da execução do programa:

Veja que adicionei o programa EAFXTRADE_V28, em 3 gráficos(EURUSD, GBPUSD,


USDJPY), a divisão do valor de 10000, foi feita corretamente.

Inclusive se o programa for anexado em mais gráficos, o valor vai continuar a ser rateado.

Existe uma opção no terminal do cliente para consultar, adicionar e remover "Variáveis
Globais" onde pode-se ver todas as GlobalVariables abertas e seus valores.

Basta acessar o Menu Ferramentas do Metatrader 4, em seguida clique em seguida clique


em Variáveis Globais, será aberto a seguinte janela:

Depois que todos os EAs forem removidos dos Gráficos, esta janela deve estar vazia sem
quaisquer registros sobre as variáveis globais abertas do terminal do cliente.

97
Erros na utilização de GlobalVariables

Se colocarmos o EA EAFXTRADE_V28 em janelas de diferentes títulos e rastrearmos


sucessivamente todos os eventos, veremos que o código opera com sucesso. No entanto, é
assim somente se pausas entre eventos são bastante grandes. Preste atenção ao operador 'if'
em OnDeinit():

If (Experts == 1) // Se existe um EA ..

Neste caso, o valor da variável global Experts é analisado. Embora reflita o valor GV, ele pode
ficar antiga (deve ser lembrado todos os programas operam em modo de tempo real). Para
entender as razões, vamos ver o diagrama a seguir:

A figura acima mostra o desenvolvimento de eventos relativos ao valor de Quantidade


GV. Vamos rastrear como esse valor vai mudar dependendo do que está acontecendo. Suponha
que a execução da EA tenha começado no momento t0. Neste momento a Quantidade de GV
ainda não existe. No período t0 - t1 A função especial OnInit() do EA é executada, como
resultado GV Quantidade é criada, seu valor no momento t1 é igual a 1. Próximos ticks de
EUR/USD iniciam a função especial OnTick(). No entanto, no período t0 - t6 existe apenas um
EA no terminal cliente, por isso o valor da Quantidade GV não muda.

No momento t6, a segunda EA é anexada ao gráfico GBP/USD. Como resultado do seu valor de
execução OnInit() das variações de quantidade de GV e no momento t7 é igual a 2. Depois
disso no momento t8 o terceiro EA é anexado ao gráfico USD/CHF, como resultado no
momento t9 GV Quantidade é igual a 3.

No momento t10 um comerciante decide remover um EA da janela EUR / USD. Note-se que a
última vez que a variável Especialistas da EA operando nesta janela foi alterada durante a
execução de OnTick() lançada no segundo tick, isto é, no período t4 - t5. No momento t10 o
valor de Experts no EA operando na janela EUR/USD ainda é igual a 1. É por isso que quando
OnDeinit() deste EA é executado, GV Quantidade será excluído como resultado da execução das
seguintes linhas:

if (Experts ==1) // If valor da variavel Experts = 1


GlobalVariableDel(Quantity); //..deleta GV

98
Assim, embora ainda existam dois EAs anexados, o GlobalVariable excluído. Não é difícil de
entender, que conseqüências isso causara nos cálculos de EAs anexados. Na execução de
OnTick(), estes EAs detectarão que o valor atual de New_Experts é igual a zero, por isso o novo
valor de Experts também será zerado. Como resultado, o valor do dinheiro não pode ser
calculado, porque na fórmula utilizada para os cálculos especialistas está no
denominador. Assim, os cálculos adicionais nas EAs serão erróneos.

Além disso, na execução das funções OnDeinit() dos EAs (ao desvincular-se de GBP/USD e
USD/CHF) a GV será aberta novamente, mas o valor será igual a -1 depois que uma delas
forem removidas e -2 após a Último ser removido. Tudo isso resultará em um valor negativo do
Dinheiro. Importante é o fato de que após todos os EAs serem destacados, a Quantidade de GV
permanecerá aberta no terminal do cliente e influenciará ainda mais a operação de todos os
EAs que usam seu valor.

Há também outro caso possível. Imagem a seguir mostra como o valor de GV mudará se antes
de um EA ser removido chegar um outro Tick.

Com base em tudo que vimos, o erro pode ser facilmente corrigido. Precisamos simplesmente
atualizamos a variável Experts antes da análise (antes da execução do operador if):

Veja o exemplo:

Tais erros algorítmicos são perigosos porque nem sempre são óbvios e é difícil detectá-los. Mas
isso não significa que um usuário deve recusar usar GlobalVariables. No entanto, isso significa
que um código de qualquer programa deve ser construído corretamente levando em conta
todos os eventos que podem influenciar o desempenho do programa.

99
O uso de variáveis globais no trabalho prático pode ser muito útil: por exemplo, isso ajuda a
informar sobre eventos críticos em um outro Gráfico (atingindo um certo nível de preço, sua
quebra, etc.), sobre a ligação de outro Consultor Especializado (com o objetivo de Partilha de
autoridade), realizar negociação sincronizada sobre vários títulos ao mesmo tempo. A variável
global do terminal do cliente também pode ser criada a partir de um indicador que calcula
alguns eventos importantes. O valor de tal variável pode ser usado por qualquer Expert Advisor
ou script operacional.

Vale apena fazer outros teste!

Matrizes

Uma grande parte da informação processada por programas de aplicação está contida em
matrizes.

Conceito de matrizes

Array é um conjunto arranjado de valores de variáveis de um tipo que têm um nome


comum. Arrays podem ser unidimensionais e multidimensionais. A quantidade máxima
admissível de dimensões em um array é quatro. Arrays de qualquer tipo de dados são
permitidos.
Elemento de matriz é uma parte de uma matriz; É uma variável indexada com o mesmo
nome e algum valor.

Indexação

O índice de elemento de matriz é um ou vários valores inteiros indicados na forma de uma


constante, variável ou expressão enumerada separada por vírgulas, entre colchetes. O índice de
elemento de matriz define unicamente o lugar de um elemento em uma matriz. O índice de
elemento de matriz é indicado após um identificador de variável (nome de matriz) e é parte
integrante de um elemento de matriz. Na indexação MQL4 inicia-se o zero.

100
A maneira de especificar índices quando cada índice está entre colchetes também é aceitável:

Um exemplo do nosso cotidiano mais próximo de uma matriz bidimensional é uma sala de
cinema. O número da linha é o primeiro valor do índice, o número do acento é o valor do
segundo índice, os espectadores são elementos da disposição, o sobrenome do cliente é o valor
de um elemento da disposição, o ingresso do cinema (especificando a linha e o lugar) é um
método Para acessar o valor de um elemento de matriz.

Declaração de matriz e acesso a elementos de matriz

Antes de usar uma matriz em um programa, ele deve ser declarado. Uma matriz pode ser
declarada como uma variável no nível global e local. Consequentemente, valores de elementos
de matriz global estão disponíveis para todo o programa, valores de um local - apenas para a
função, na qual é declarado. Uma matriz não pode ser declarada no nível de um terminal de
cliente, é por isso que as variáveis globais do terminal de cliente não podem ser reunidas em
uma matriz. Os valores dos elementos da matriz podem ser de qualquer tipo. Os valores de
todos os elementos da matriz são do mesmo tipo, ou seja, do tipo indicado na declaração de
matriz. Ao declarar uma matriz, o tipo de dados, o nome da matriz e o número de elementos de
cada dimensão devem ser especificados:

101
O acesso aos elementos da matriz é implementado de forma elementar, ou seja, em um
momento de tempo, apenas um componente pode ser acessado. O tipo de valor do
componente de matriz não é especificado no programa. O valor do componente de matriz pode
ser atribuído ou alterado usando o operador de atribuição:

O valor dos elementos de matriz na Figura:

são os seguintes:

- para uma matriz unidimensional, o valor do elemento Mas[4] é o número inteiro 34;

- para matriz bidimensional, o valor do elemento Mas[3,7] é o número inteiro 28;

- para a matriz tridimensional, o valor do elemento Mas[5,4,1] é o número inteiro 77.

Nota: o valor mínimo do índice de elemento de matriz é 0 (zero) eo valor máximo é menor em
um que o número de elementos em uma dimensão correspondente indicada na declaração de
matriz.

Por exemplo, para a matriz Mas[10][15] o elemento com o menor valor de índices é o elemento
Mas[0,0], aquele com valores de índices máximos é o elemento Mas[9,14].

Operações com matrizes também podem ser realizadas usando funções padrão.

102
Uma matriz pode ser inicializada apenas por constantes de um tipo correspondente. As matrizes
unidimensionais e multidimensionais são inicializadas pela sequência unidimensional de
constantes separadas por vírgulas. A sequência é incluída em colchetes:

Int Mas_i[ 3 ][ 4 ] = {0 , 1 , 2 , 3 , 10 , 11 , 12 , 13 ,20 , 21 , 22 , 23};

double Mas_d[ 2 ][ 3 ] = { 0.1 , 0.2 , - 0.3 , - 10.2 , 1.5 , 7.0 };

Na sequência inicializada, uma ou várias constantes podem ser omitidas. Nesse caso, os
elementos de matriz correspondentes de tipo numérico são inicializados por zero, os elementos
de matrizes de tipo string são inicializados pelo valor de string "" (aspas sem espaço), isto é,
por uma linha vazia (não deve ser confundida com um espaço). O próximo programa exibe
valores de arrays, inicializados por uma seqüência com omissão de alguns valores:

Veja Programa EAFXTRADE_V29

Veja o resultado:

103
Se o tamanho de uma matriz inicializada não tiver a dimensão especificada, ela será definido
por um compilador baseado na seqüência inicializada. Uma matriz também pode ser inicializada
pela função padrão ArrayInitialize(). Todos os arrays são estáticos, ou seja, são de tipo
estático, mesmo que na inicialização isso não é explicitamente indicado. Isso significa que todos
os arrays preservam seus valores entre chamadas da função, em que a matriz é declarada.

Todos os arrays usados no MQL4 podem ser divididos em dois grupos: arrays definidos pelo
usuário (criados por iniciativa de um programador) e arrays-timeseries (arrays com nomes
predefinidos e tipos de dados).

Definir tamanhos de arrays definidos pelo usuário e valores de seus elementos depende de
como um programa é criado e em última instância, conforme a vontade do programador.

Valores de elementos de matriz definidos pelo usuário são preservados durante todo o tempo
de execução do programa e podem ser alterados após cálculos. No entanto, valores de
elementos em arrays-timeseries não podem ser alterados, seu tamanho pode ser aumentado
quando o histórico é atualizado.

Arrays definidos pelo usuário

Vamos ver o próximo exemplo onde o programa tem a função de analisar o preço e fazer uma
analise com base no nível estipulado pelo usuário.

Se o preço exceder um determinado nível, o programa vai exibir uma mensagem, em que o
excesso é indicado (até 100 pontos), caso contrário ele mostrara de forma escrita a quantidade
e pontos que o preço esta de distancia do limite declarado pelo usuário.

104
Veja que foi feito a leitura da matriz Text[101], sendo que o LOOP externo inicializou na
posição 20, com limite até 90, incrementando de 10 em 10.

Veja a continuação do programa:

Na função OnTick() o programa faz uma verificação Tick a Tick para saber se o preço esta
dentro do Nivel.

Caso a Variável Delta Retorne um valor MENOR que ZERO, será mostrado a mensagem “Preço
abaixo do nível”.

Caso a Variável Delta Retorne um valor MAIOR que 100, será mostrado a mensagem “Mais de
cem pontos”.

Se Delta estiver fora das duas verificações, ai sim será mostrado a mensagem referente a
quantos pontos de distancia estamos do limite definido pelo usuário.

Veja programa EAFXTRADE_V30

Agora baixe esse programa, e veja o resultado no seu computador.

Veja o resultado do teste:

105
Arrays-Timeseries

Array-timeseries é uma matriz com um nome predefinido (Open, Close, High, Low, Volume
ou Time), cujos elementos contêm valores de características correspondentes de barras
históricas.

Os dados contidos em arrays-timseries possuem uma informação muito importante e são


amplamente utilizados na programação em MQL4. Cada array-timeseries é uma matriz
unidimensional e contém dados históricos sobre uma determinada característica
de barra. Cada barra é caracterizada por um preço de abertura Open[], preço de fechamento
Close[], preço máximo High[], preço mínimo Low[], volume Volume[] e tempo de abertura
Time[]. Por exemplo, array-timeseries Open[] traz informações sobre os preços de abertura
de todas as barras presentes em uma janela de segurança: o valor do elemento array Open[1]
é o preço de abertura da primeira barra, Open[2] é o preço de abertura de A segunda barra, e
sucessivamente. O mesmo é acontece para os outros timeseries.

Barra zero é a barra atual que ainda não se formou completamente. Em uma janela de gráfico
a barra zero é a última direita.

Barras (índices correspondentes de matrizes-série de tempos) contagem é iniciado a partir da


barra zero. Os valores dos elementos array-timeseries com o índice [0] são valores que
caracterizam a barra zero. Por exemplo, o valor de Open[0] é o preço de abertura de uma barra
zero. A figura a seguir mostra a numeração das barras e características da barra (refletida em
uma janela de gráfico quando um cursor do mouse é movido para uma imagem).

Veja na próxima imagem, que iremos mostrar os dados da BARRA 13:

106
Após algum tempo, a barra atual será formada e uma nova barra aparecerá em uma janela de
segurança. Agora, esta nova barra será uma barra zero e a barra que acaba de se formar vai se
tornar o primeiro depois da BARRA ZERO(com o índice 1):

Os valores dos elementos array-timeseries são características próprias de uma barra, e são
alterados (exceto as seguintes características de uma barra zero: Close [0], High [0], Low [0],
Volume [0]); Seu aprofundamento no futuro para o momento atual e é mudado no decorrer do
tempo.

Quer dizer o seguinte: veja a imagem abaixo:

107
Sempre que um novo Candle surgir, o Gráfico é indexado novamente, significa que neste
gráfico mostrado acima, o Open[0] agora é o candle laranja, sendo que o Open[0] era o candle
anterior antes do surgimento do candle laranja.

É importante saber isso pois Open[0] de agora, nem sempre vai ser o Open[0] de daqui a
pouco.

Vamos mostrar um exemplo onde vamos encontrar o preço mínimo e máximo entre as últimas
n barras. E faremos o uso de Arrays-timeseries

Exemplo:

Veja programa EAFXTRADE_V31

O programa acima funciona da seguinte maneira:

1. Criamos duas variáveis (Minimum e Maximum), carregamos o preço delas com o


preço de cotação atual.
2. Criamos um “for” que faz a leitura do candle [0] até a quantidade definida na variável
“Quant_Bars”

108
3. Fazemos a verificação, se o menor preço (Low[i]) é menor que o valor carregado na
variável Minimum, caso o valor seja menor, então atualizamos a variável Minimum
com o novo valor.
4. Fazemos a verificação, se o maior preço (High[i]) é maior que o valor carregado na
variável Maximum, caso o valor seja maior, então atualizamos a variável Maximum
com o novo valor.
5. Após concluir o LOOP do ‘for’, mostramos um Alerta com os valores atualizados.

Veja o resultado:

Existe uma maneira mais simples e confiável de fazer o mesmo trabalho - analisando o tempo
de abertura de uma barra zero. O tempo de abertura de uma barra zero é a característica da
barra que não muda durante a formação da barra.

Os Novos ticks vêm durante a formação de um bar e podem mudar seu High[0], Close[0] e
Volume[0]. Mas características como Open[0] e Time[0] não são alteradas.

No exemplo abaixo mostramos uma outra forma de trazer o mesmo resultado do exemplo
acima.

A diferença esta no uso da função ArrayMinimum() e da função ArrayMaximum(), com o


uso dessas funções não foi preciso utilizar o ‘for’ para passar em todos os 30 candles.

Fizemos também a criação de uma função que verifica a existência de um novo candle, com
base no array Time[0].

109
Se o valor New_Time (calculado no histórico anterior) não é igual a Time[0] de uma barra
zero, o programa entende que é de fato a formação de uma nova barra. Nesse caso, o controle
é passado para o corpo do operador 'if', onde é atribuído o novo tempo de abertura da barra
zero para variável New_Time e atualizado o valor da variável New_Bar para true.

Veja programa completo:

Veja programa EAFXTRADE_V32.

Veja resultado:

110
111
Programação prática em MQL4
Esta segunda parte do livro considera as seguintes questões: a ordem de realização de
operações comerciais, os princípios de codificação e uso de scripts simples, Expert Advisors e
indicadores, bem como funções padrão frequentemente usadas na programação em
MQL4. Todas as seções contêm alguns exemplos de programas prontos para uso, mas com
campo de aplicação limitado.

A seção denominada Criação de Programas Normais dá um exemplo que você pode usar como
base para projetar seu próprio Expert Advisor simples para ser usado na negociação real.

Todos os critérios de negociação abaixo são usados para propósitos educacionais e não devem
ser considerados como diretrizes na negociação em contas reais.

Programação de Operações Comerciais


Ao programar operações comerciais, você deve considerar os requisitos e limitações
relacionados às características de ordens e regras aceitas em seu centro de negociação, bem
como as características especiais da tecnologia de execução de ordens comerciais. A seção
fornece a descrição detalhada da ordem de realizar transações e contém uma série de
exemplos que explicam os fins de todas as funções comerciais utilizadas para formar ordens de
comércio. A seção contém alguns scripts prontos para uso restrito.

Maneira comum de começar

Todos os cálculos e outras ações executadas devido à execução de um programa aplicativo


podem ser divididos em dois grupos pelo local de sua execução: aqueles executados no PC do
usuário e aqueles executados no lado do servidor. Uma quantidade significativa de cálculos é
realizada do lado do usuário. Este grupo inclui a execução de programas de aplicação. As
profissões pertencem ao segundo grupo. Fazer negócios implica conversão de dados no
servidor.

Considerando os negócios, distinguiremos os seguintes termos:

Ordem de mercado - é uma ordem executada para comprar ou vender ativos para um
símbolo (segurança). Uma ordem de mercado é exibida na janela de símbolo até que a ordem
seja fechada.

Ordem pendente é uma ordem comercial para comprar ou vender ativos quando o nível de
preço predefinido é atingido. A ordem pendente é exibida na janela de símbolo até que ela se
torne uma ordem de mercado ou seja excluída.

O pedido de comércio é um comando feito por um programa ou por um comerciante a fim


executar um comércio.

O comércio é abertura, fechamento ou modificação de ordens de mercado e pendentes.

Diagrama

Três componentes estão envolvidos na realização de negócios: um programa aplicativo, o


terminal cliente (MetaTrader4) e o servidor. Uma solicitação é formada no programa (como

112
mencionamos acima, qualquer programa aplicativo pode ser executado somente no PC do
usuário, nenhum programa aplicativo é instalado no servidor). O pedido formado pelo programa
será passado para o terminal cliente que, por sua vez, envia o pedido ao servidor. No lado do
servidor, a decisão sobre a execução da solicitação ou rejeição será feita. As informações sobre
os resultados obtidos serão passadas pelo servidor para o terminal cliente e, em seguida, para
o programa.

Solicitações

Um pedido de comércio ou abertura de ordem pode ser feito por um comerciante ou por um
programa (EA). Para que um operador possa fazer uma solicitação, o terminal cliente fornece o
painel de controle "Nova Ordem".

Quando se trata de Programas (EA) As solicitações são feitas de acordo com o algoritmo criado
pelo desenvolvedor, como resultado da execução de funções comerciais.

Em nenhum outro lugar (nem no terminal do cliente nem no servidor) as solicitações


comerciais são formadas espontaneamente.

Recursos do Programa

Dependendo do algoritmo, um programa pode formar solicitações diferentes - para abertura,


fechamento ou modificação de ordens de mercado e pendentes. As funções comerciais a seguir
são usadas em um programa para enviar solicitações de comercio:

 OrderSend() – Utilizado para abrir ordens no mercado(execução instantânea ou


Pendente).
 OrderClose () e OrderCloseBy () - para fechar ordens que estão abertas no
mercado.
 OrderDelete () - para excluir pedidos pendentes ;
 OrderModify () - para modificar Ordens que já estão no mercado e pendentes.

As funções de comércio acima podem ser usadas somente em consultores especializados e


scripts. A utilização destas funções nos indicadores é proibida.

Existem outras funções que pertencem ao módulo comercial (consulte o arquivo de ajuda no
MetaEditor). No entanto, a sua execução é atribuída a chamar o ambiente de informação do
terminal, a fim de obter informações de referência, por isso não resulta na formação de pedidos
e chamada para o servidor.

Recursos do Terminal do Cliente

113
Uma solicitação feita pelo programa como resultado da execução de uma função comercial é
passada para o terminal cliente para processamento. O terminal cliente analisa o conteúdo da
solicitação e executa uma das duas ações a seguir: envia a solicitação ao servidor para que ela
seja executada no servidor ou rejeita a solicitação e não envia nada para o servidor.

O terminal cliente permite que apenas as solicitações corretas sejam enviadas ao


servidor. Se o programa é codificado de tal forma que ele forma, por exemplo, um pedido
para abrir uma ordem a um preço não existente, o terminal cliente não enviará esta solicitação
ao servidor. Se o programa formar solicitações corretas (os pedidos são abertos e fechados com
o preço conhecido mais recente, o valor da ordem está dentro do intervalo limitado pelo centro
de negociação, etc.), então esse pedido será enviado ao servidor.

Somente um thread de execução é fornecido no terminal do cliente para realizar


transações. Isso significa que o terminal cliente pode trabalhar simultaneamente apenas com
um pedido. Se houver vários Expert Advisors ou scripts negociando no terminal do cliente e
nenhum programa tiver passado uma solicitação de negociação para o terminal do cliente, as
solicitações de comércio de todos os outros Expert Advisors e scripts serão rejeitadas até que o
terminal cliente complete o processamento do pedido atual, , Até que o segmento comercial
seja livre.

Recursos do Servidor

As informações sobre o histórico comercial de cada conta (abertura, encerramento, modificação


de ordens) são altamente protegidas pelo servidor e têm uma prioridade maior em comparação
com o histórico de negócios armazenados no terminal cliente. O direito de executar solicitações
comerciais é concedido apenas a um revendedor ou ao servidor que processa solicitações
automaticamente (se o centro de negociação fornecer ao servidor esse recurso por um
determinado período de tempo). Um pedido que é entregue no servidor pode ser executado ou
rejeitado. Se o pedido de comércio é executado (ou seja, uma negociação é feita), o servidor
fará todas as conversões necessárias de dados. Se o pedido de comércio é rejeitado, o servidor
não converte quaisquer dados. Não importa qual a decisão (para executar ou rejeitar um
pedido).

Uma solicitação comercial formada como resultado da execução do programa e uma solicitação
de negociação formada manualmente pelo operador são absolutamente iguais, do ponto de
vista do servidor, de modo que o servidor não faz distinção entre solicitações ao processá-las.

Em resumo o servidor não sabe se a ordem esta sendo gerada manualmente ou através de um
EA.

Também é possível no lado do servidor proibir o funcionamento de Expert Advisors no terminal


do cliente. Às vezes é necessário, se a operação do programa causar conflitos. Por exemplo, se
a implementação de um algoritmo incorreto resulta em que o programa forma continuamente
solicitações comerciais alternadas para abertura e fechamento de ordens com intervalos de
tempo muito pequenos (por exemplo, a cada marca) ou se os pedidos de abertura, exclusão ou
Modificação de ordens pendentes são muito frequentes.

Existe corretoras que a funcionalidade “Negociação Automatizada” fica desabilitada no servidor,


neste caso, você deve entrar em contato com a corretora para pedir a liberação da
funcionalidade.

114
Procedimento de Negociação

O procedimento de realizar transações é interativo e realizado no modo de tempo real. O


diagrama abaixo mostra todos os eventos relacionados com a realização de um comércio.

Evento 0. O programa é lançado para execução no momento t0.

Evento 1. No momento t1, o programa formou um pedido de comércio como resultado da


execução de uma função comercial. A solicitação de comércio é passada para o terminal do
cliente. Nesse momento, o programa passa o controle para o terminal do cliente e a execução
do programa é interrompida (o ponto vermelho no diagrama).

Evento 2. O terminal do cliente recebeu o controle e as informações sobre o conteúdo da


solicitação. Dentro do período de tempo entre t2 e t3, o terminal cliente analisa o conteúdo do
pedido de comércio e toma uma decisão sobre outros eventos.

Evento 3. O terminal cliente executa essa decisão tomada (uma de duas alternativas).

Alternativa 1. Se o pedido de comércio formado como resultado da execução de uma das


funções comerciais esta incorreto, o controlo é passado para o programa. Nesse caso, o
próximo evento será o Evento 4 (isso pode acontecer se, por exemplo, o programa tiver
enviado o pedido de abertura de uma ordem, cujo valor exceda o valor da conta disponível).

Evento 4. O programa recebeu o controle (momento t4, ponto verde) e pode continuar a
execução a partir do local onde a solicitação foi formada anteriormente. No mesmo momento, o
programa recebeu a informação de que a ordem comercial não foi executada. Você pode
descobrir sobre o motivo, para o qual a solicitação de comércio não foi executada, analisando a
ode do erro retornado. Abaixo vamos considerar a questão de como fazer isso. Aqui, apenas
deve ser notado que nem todas as solicitações resultam na execução de negócios. Nesse caso,
o programa formou uma solicitação incorreta, o que resulta em que o terminal cliente rejeitou
essa solicitação e retornou o controle para o programa. Nesse caso, nenhuma referência ao
servidor ocorre.

Alternativa 2. Se o programa formou uma solicitação de comércio correto, o terminal cliente


envia essa solicitação para o servidor; O próximo evento será Evento 5 (o momento de t5) - o
servidor receberá a solicitação de negociação. A ligação entre o terminal cliente e o servidor é
estabelecida via Internet, sendo que o tempo gasto no envio do pedido de transação para o
servidor (intervalo de tempo entre t3 e t5) é completamente dependente da qualidade da
ligação. Para uma conexão de boa qualidade, este período de tempo pode ser de

115
aproximadamente 5 a 10 ms, enquanto que pode ser medido em segundos inteiros em conexão
ruim.

Evento 5. No momento t5, o servidor recebeu a solicitação de negociação. O servidor pode


executar ou rejeitar esta solicitação recebida. A decisão de executar ou rejeitar o pedido pode
ser feita no lado do servidor dentro de um certo período de tempo (no momento t6). O
intervalo de tempo entre t5 e t6 pode variar de alguns milissegundos a dezenas de segundos,
dependendo da situação. Em alguns casos, se o servidor opera no modo automatizado e não há
movimentos rápidos no mercado e outros comerciantes não são muito ativos, o pedido de
comércio pode ser executado ou rejeitado em vários milissegundos. Em outros casos, se o
servidor está sobrecarregado devido à alta atividade dos comerciantes e se a decisão sobre a
execução ou rejeição do pedido é feita por um negociante humano,

Evento 6. Se não houver mudanças consideráveis no mercado dentro do intervalo de tempo


desde o momento da formação do pedido de comércio pelo programa (t1) até o momento da
tomada de decisão pelo servidor (t6), o pedido de comércio será executado, como uma
regra. Se o preço do símbolo mudou dentro deste tempo ou o valor da ordem a ser aberta é
superior ao patrimônio líquido livre da conta no momento de tomar a decisão, ou outros
impedimentos ocorrem, então o servidor decide rejeitar o pedido de comércio.

A rejeição do servidor de pedidos comerciais (embora eles já tenham sido verificados pelo
terminal cliente) é comum. Em geral, as solicitações comerciais que são entregues ao servidor
são aceitas para execução. No entanto, em alguns casos, um pedido pode ser rejeitado, e o
programa de aplicação tem de ser codificado de tal forma que considere essa possibilidade e
funcione corretamente em tais situações.

Seja qual for a decisão (para executar / rejeitar uma solicitação de negociação, Evento 6), a
decisão é feita pelo servidor, as informações sobre ele são enviadas pelo servidor para o
terminal cliente que entregou a solicitação.

Evento 7. O terminal do cliente recebeu a resposta do servidor. A resposta do servidor segue o


mesmo caminho através da Internet como a solicitação entregue ao servidor. De modo que o
tempo gasto com o recebimento da resposta do servidor depende completamente da qualidade
da conexão. De acordo com as modificações feitas no servidor, o terminal cliente irá refletir as
alterações correspondentes. Por exemplo, se a execução de uma solicitação de negociação
resultar no fechamento ou abertura de uma ordem, o terminal do cliente exibirá este evento
graficamente na janela de símbolo e textualmente na janela 'Terminal' (nas guias 'Negociação'
e 'Histórico da conta'). . Se o servidor tiver rejeitado a solicitação de comércio, nenhuma
alteração será feita em qualquer janela do terminal cliente.

Evento 8. O terminal do cliente concluiu a exibição de alterações e está passando o controle


para o programa.

Evento 9. O programa recebeu o controle e pode continuar operando.

Conflitos em fazer negócios. Erro 146

Ao considerar acima as características do terminal do cliente, mencionamos que o terminal do


cliente poderia processar apenas um pedido por vez. Vamos agora considerar quais eventos
ocorrerão se várias solicitações formadas por diferentes programas forem passadas para o
terminal cliente.

116
Podemos ver que dois Trading Expert Advisors são lançados para execução no terminal
cliente simultaneamente. EA1 formou uma solicitação de negociação no momento t1 e passou-o
o terminal cliente no momento t2.

EA2 também criou uma solicitação e refere-se ao terminal cliente quando o terminal cliente está
processando a primeira solicitação (período de t2 a t3). Nessa situação, o terminal cliente não
pode considerar a solicitação formada por EA2, portanto, ele irá rejeitar essa solicitação e
retornar o controle para EA2. Observe que, neste caso, o pedido é rejeitado pelo terminal
cliente não para a solicitação está incorreta, mas porque o terminal está ocupado com o
processamento do outro pedido. EA2 continuará operando. Ele pode analisar o código de erro
que explica o motivo pelo qual o pedido foi rejeitado (no nosso caso, é o erro 146).

Se for EA2 (em um caso geral, pode ser um ou vários programas de negociação) que passa sua
solicitação para o terminal cliente dentro do período de tempo entre t1 e t4, então esse pedido
será rejeitado (um grupo de eventos no Rosa). O terminal cliente fica livre no momento t4
(ponto verde). A partir deste momento, o EA2 pode passar com sucesso sua solicitação para o
terminal cliente (um grupo de eventos na área verde). Esta solicitação será recebida e
considerada pelo terminal cliente que pode finalmente rejeitá-la, também, mas pela razão de
sua incorreção, ou pode enviar essa solicitação ao servidor.

Se a solicitação comercial criada por EA1 for considerada pelo terminal cliente como correta,
essa solicitação será enviada pelo terminal cliente para o servidor no momento t3. Neste caso,
o terminal do cliente muda para o modo de espera e não pode considerar quaisquer outros
pedidos de comércio. O terminal cliente só ficará livre para considerar de outras solicitações
comerciais no momento t9. Assim, de acordo com a Variante 2, o terminal cliente não pode
analisar pedidos de comércio dentro do período de tempo entre t1 e t9. Se dentro desse
período qualquer programa se refere ao terminal cliente para passar uma solicitação para
consideração, o terminal cliente rejeitará este evento e passará o controle para o programa (um
grupo de eventos na área cor-de-rosa dentro do período de tempo entre t6 E t7). O programa
que recebeu o controle continua seu funcionamento e,

A partir do momento t9, o terminal cliente será completamente livre para analisar quaisquer
outros pedidos de comércio. EA2 pode passar com êxito a solicitação de negociação para o
terminal cliente dentro do período de tempo que segue o momento t9. De acordo com o cliente
terminal considera este pedido para ser correto ou não, o pedido será passado pelo terminal
cliente para o servidor ou rejeitado.

A análise de erros que ocorrem na realização de negócios é considerada em mais detalhes nas
seções abaixo.

117
Características e Regras de Ordem para Fazer Negócios

Antes de começar a descrever as funções comerciais, devemos considerar parâmetros que


caracterizam os preços de mercado, os tipos de pedidos, suas características, bem como as
regras para fazer negócios.

Características dos símbolos

Em primeiro lugar, devemos considerar o princípio utilizado pelas corretoras para formar preços
de títulos. Este princípio consiste em que o corretor oferece ao comerciante uma cotação de
duas vias para a realização de comércios.

Citação de duas vias é um par ligado de preços de mercado oferecidos pelo corretor para a
compra e venda de ativos no momento presente.

Bid é o menor dos dois preços oferecidos pelo corretor em uma cotação.

Ask é o maior dos dois preços oferecidos pelo corretor em uma cotação.

Point é a unidade de medição de preço para um símbolo (a variação de preço mínima possível,
o último valor significativo do valor do preço).

Spread é a diferença entre o maior e o menor preço em pontos.

Tipos de Ordem e Características

Existem seis tipos de ordem no total: dois tipos de ordens de mercado e quatro tipos de
pedidos pendentes.

Buy é uma ordem de mercado que define a compra.

Sell é uma ordem de mercado que define a venda.

118
BuyLimit é uma ordem pendente para comprar ativos para uma segurança a um preço inferior
ao atual. A ordem será executada (modificada para a ordem de compra no mercado) se o preço
Ask atingir ou cair abaixo do preço definido na ordem pendente.

SellLimit é uma ordem pendente para vender ativos para um título a um preço superior ao
atual. A ordem será executada (modificada na ordem de venda do mercado) se o preço da
Oferta atingir ou ficar acima do preço definido na ordem pendente.

BuyStop é uma ordem pendente para comprar ativos para uma segurança a um preço superior
ao atual. A ordem será executada (modificada para a ordem de compra do mercado) se o preço
de Ask atingir ou sobe acima do preço definido na ordem pendente.

SellStop é uma ordem pendente para vender ativos para um título a um preço inferior ao
atual. A ordem será executada (modificada para venda no mercado) se o preço da Oferta
atingir ou cair abaixo do preço definido na ordem pendente.

Lot é a quantidade de lotes.

StopLoss é uma ordem de paragem; É um preço estabelecido pelo trader, no qual uma ordem
de mercado será fechada se o preço do símbolo se move em uma direção que produz perdas
para a ordem.

TakeProfit é uma ordem de paragem; É um preço estabelecido pelo comerciante, no qual uma
ordem de mercado será fechada se o preço do símbolo se move em uma direção que produz
lucros para a ordem.

Requisitos de negociação e limitações

Para formar solicitações corretas de comércio em seus programas de aplicação (Expert Advisors
e scripts), você deve levar em consideração os requisitos e limitações existentes. Vamos
considerá-los em mais detalhes.

Todos os negócios são realizados a preços corretos. O preço de execução de cada transação é
calculado com base no preço correto de uma cotação bidirecional.

A regra acima é a regra comum para todos os participantes no mercado e não pode ser
alterada à vontade dos desenvolvedores de uma plataforma de negociação ou com base em um
acordo entre um corretor e um comerciante. Isso significa, por exemplo, que uma ordem de
mercado só pode ser aberta ao preço de mercado atual, mas não a qualquer outro preço. O
procedimento de cálculo do preço correto para diferentes operações é considerado abaixo.

Ao calcular preços corretos, também é necessário considerar as limitações do provedor de


serviços (centro de negociação). Essas limitações incluem a distância mínima e a distância de
congelamento. Essas limitações significam que o corretor precisa de algum tempo para os
preparativos para a realização de novos negócios, seja convertendo uma ordem pendente em
um mercado ou fechando uma ordem por ordem stop.

Os centros de negociação limitam o valor da diferença mínima admissível entre o preço de


mercado e o preço solicitado de cada ordem de paragem de uma ordem de mercado, entre o
preço de mercado e o preço pedido de uma encomenda pendente, bem como entre o preço
pedido de um pedido pendente Ordem e os preços solicitados de suas ordens de parada. Isso
significa, por exemplo, que em uma solicitação de abertura de uma ordem de mercado, você

119
pode especificar apenas os valores de preço de parada que não estão distantes do preço atual
menor que a distância mínima prescrita. Uma solicitação comercial contendo preços de parada
que estejam mais próximos do preço de mercado do que a distância mínima é considerada pelo
terminal cliente como incorreta. Diferentes centros de negociação podem estabelecer limites
específicos para o centro específico para a distância mínima permitida. Como uma regra, O
valor dessa distância varia entre 1 e 15 pontos. Para os títulos mais utilizados (EUR/USD, GBP/
USD, EUR/CHF, etc.), esta distância faz na maioria dos centros de negociação 3-5 pontos. Não
há limitações para a distância máxima. O valor da distância mínima para qualquer símbolo pode
ser alterado pelo corretor a qualquer momento (isso geralmente precede a transmissão de
notícias comerciais importantes). Não há limitações para a distância máxima.

A distância Freeze limita a possibilidade de modificar os preços solicitados para abrir os pedidos
pendentes, bem como os níveis de parada solicitados para as ordens de mercado que estão na
área de congelamento. Isto significa, por exemplo, que, se o preço de mercado for 1.3800, a
ordem pendente é colocada para ser aberta em 1.3807 e a receita do corretor é 10, a ordem
pendente está na área de congelamento, ou seja, não é possível modificá-la ou excluí-la. Em
um mercado calmo, os corretores geralmente não definem a distância de congelamento, ou
seja, seu valor = 0. No entanto, durante o período anterior à notícia importante ou com alta
volatilidade, o corretor pode definir um certo valor de uma distância de congelamento. Em
condições diferentes e para diferentes corretores, esse valor pode variar de 1 a 30 pontos para
símbolos básicos e assumir valores mais altos para outros símbolos.

As limitações dos níveis de preços limitadas pelos valores de distância mínima e de distância de
congelamento são calculadas com base em preços corretos.

Abertura / fechamento de ordens de mercado

A abertura de uma ordem de mercado implica a compra ou venda de alguns ativos para um
símbolo aos preços de mercado atuais.

Para abrir uma ordem de mercado, use a função OrderSend().

Para fechá-lo, use a função OrderClose().

O preço correto para ordem de Compra é o mais recente preço de mercado conhecido Ask.

O preço correto para ordem de Venda é a última oferta conhecida de Bid.

120