Foi | Tornou-se | |
---|---|---|
Ativação | Todos os tipos de ordens pendentes e ordens SL/TP segundo o Bid/Ask | Ordens limit segundo o Bid/Ask Ordens stop-limit e SL/TP segundo o Last |
Execução | Todos os tipos de ordens pendentes e ordens SL/TP segundo o preço na ordem anunciada | Todos os tipos de ordens pendentes e ordens SL/TP segundo o Bid/Ask no momento de ativação |
Examinemos um exemplo no instrumento Si-6.16. Tendo os atuais preços Bid=72570, Ask=72572, Last=72552 colocamos a ordem Buy Stop com preço de ativação 72580. No fluxo de preços, obtemos uns novos preços:
Nos instrumentos financeiros, o peço Last é o gatilho para a ativação de ordens stop. Por isso, a obtenção, no fluxo de preços, dum Last = 72 580 resultou na ativação das ordens Buy Stop. Anteriormente, o preço 72.580 era utilizado precisamente para a execução dessa ordem. Este comportamento era impróprio porque o preço Ask=72580, para a execução de operações de compra no mercado, não existia.
2016.05.10 12:47:53 Core 1 5.10 Mb of history processed in 0:00.842 2016.05.10 12:47:53 Core 1 GBPUSD: history synchronization completed [5225 Kb]
A atualização estará disponível através do sistema LiveUpdate.
Em resposta aos numerosos pedidos dos traders foi desenvolvida uma versão web da plataforma MetaTrader 5. O novo produto combina a comodidade e o caráter multi-plataforma com as vantagens da quinta versão para PC, isto é: velocidade, faceta multimercado e características de negociação melhoradas.
A plataforma web MetaTrader 5 agora está disponível no site da MQL5.community. Ela permite negociar nos mercados financeiros através de qualquer navegador em qualquer sistema operativo (Windows, Mac, Linux). E, para isso, não precisa de instalar nenhum programa adicional, de fato, basta ter acesso à internet.
Na versão beta, os traders têm imediatamente à sua disposição:
Sistema de compensação
Este sistema de registro implica que
num dado momento, possa haver apenas uma posição aberta, segundo um
mesmo símbolo, na conta:
Neste caso, não importa a ação pela qual é realizada a transação na
direção oposta, por outras palavras, é indiferente se foi resultado da
execução de uma ordem de mercado ou devido à ativação de uma ordem
pendente.
Abaixo mostramos um exemplo da execução de duas transações de compra de EURUSD com um volume de 0,5 lotes cada:
Como resultado da execução destas transações, temos uma posição geral com um volume de 1 lote.
Sistema de cobertura
Este sistema de registro permite que você tenha múltiplas posições do mesmo instrumento, incluindo em direções opostas.
Se, segundo um instrumento de negociação, existir uma posição aberta e o
trader executar uma nova transação (ou se estiver ativa uma ordem
pendente), ocorrerá a abertura de uma nova posição. A posição atual não
será alterada.
Abaixo mostramos um exemplo da execução de duas transações de compra de EURUSD com um volume de 0,5 lotes cada:
Como resultado da execução destas transações, temos a abertura de duas posições distintas.
Novo tipo de operação de negociação Close By
Para contas com
cobertura de registro de posições foi adicionado um novo tipo de
operação de negociação, isto é, o fechamento de uma posição usando uma
oposta. Esta operação permite fechar simultaneamente duas posições
opostas de um mesmo instrumento. Se as posições opostas tiverem
diferentes números de lotes, então, permanecerá aberta apenas uma das
duas ordens. O seu volume será igual à diferença dos lotes de duas
posições fechadas, e a direção da posição e o preço de abertura serão
iguais à maior (em volume) das posições fechadas.
Em comparação com o fechamento individual de duas posições, o fechamento da oposta permite ao trader poupar um spread:
Ao fechar uma posição usando uma oposta, você estará colocando uma ordem do tipo "close by". Nos comentários estão indicados os bilhetes das posições fechadas. Ao executar duas transações do tipo "out by", estará sendo fechado um par de posições opostas. O tamanho do lucro/perda brutos, resultante do fechamento de duas posições, é indicado apenas numa única transação.
Quando fizer a importação, os bilhetes de ordens e posições (incluindo
as ordens do histórico) não serão salvos, uma vez que uma entrada no
histórico de negociação MetaTrader 4 pode corresponder até a 4 entradas
no histórico da MetaTrader 5. São colocados novos bilhetes para todas as
entradas de negociação.
Os números das contas podem ser salvos ou substituídos por novos, dependendo de como a corretora faça a importação.
class CAnimal { public: CAnimal(); // construtor virtual void Sound() = 0; // função virtual pura private: double m_legs_count; // número de patas do animal };Aqui a função Sound() é virtual pura, porque está declarada pelo especificador da função virtual PURE (=0).
class CAnimal { public: virtual void Sound()=NULL; // PURE method, deve ser redefinido no descendente, a mesma classe tornou-se abstrata e não pode ser criada }; //--- descendente da classe abstrata class CCat : public CAnimal { public: virtual void Sound() { Print("Myau"); } // PURE redefinido, a classe CCat não é abstrata e pode ser criada }; //--- examples of wrong use new CAnimal; // erro 'CAnimal' - o compilador emitirá o erro "cannot instantiate abstract class" CAnimal some_animal; // erro 'CAnimal' - o compilador emitirá o erro "cannot instantiate abstract class" //--- exemplos de uso correto new CCat; // não há erro - a classe CCat não é abstrata CCat cat; // não há erro - a classe CCat não é abstrataRestrições sobre o uso de classes abstratas
//+------------------------------------------------------------------+ //| Classe básica abstrata | //+------------------------------------------------------------------+ class CAnimal { public: //--- função virtual pura virtual void Sound(void)=NULL; //--- função void CallSound(void) { Sound(); } //--- construtor CAnimal() { //--- chamada direta do método virtual Sound(); //--- chamada indireta (através de una terceira função) CallSound(); //--- no construtor e/ou destrutor sempre são chamadas suas funções, //--- apesar do caráter virtual e da redefinição da função da chamada no descendente //--- se a função chamada for virtual pura, então, //--- a chamada provocará um erro crítico de execução: "pure virtual function call" } };No entanto, os construtores e destruidores de classes abstratas podem chamar outras funções membro.
typedef int (*TFunc)(int,int);Agora TFunc é um tipo e é possível declarar o indicador mutável para a função:
TFunc func_ptr;Na mutável func_ptr é possível armazenar o endereço da função para, no futuro, chamá-la:
int sub(int x,int y) { return(x-y); } int add(int x,int y) { return(x+y); } int neg(int x) { return(~x); } func_ptr=sub; Print(func_ptr(10,5)); func_ptr=add; Print(func_ptr(10,5)); func_ptr=neg; // error: neg is not of int (int,int) type Print(func_ptr(10)); // error: there should be two parametersIndicadores para funções podem ser armazenados e transferidos como um parâmetro. É impossível obter um indicador para um método não estático de uma classe.
ulong PositionGetTicket( int index // número na lista de posições );
bool PositionSelectByTicket( ulong ticket // bilhete da posição );
Sistema de compensação
Este sistema de registro implica que
num dado momento, possa haver apenas uma posição aberta, segundo um
mesmo símbolo, na conta:
Neste caso, não importa a ação pela qual é realizada a transação na
direção oposta, por outras palavras, é indiferente se foi resultado da
execução de uma ordem de mercado ou devido à ativação de uma ordem
pendente.
Abaixo mostramos um exemplo da execução de duas transações de compra de EURUSD com um volume de 0,5 lotes cada:
Como resultado da execução destas transações, temos uma posição geral com um volume de 1 lote.
Sistema de cobertura
Este sistema de registro permite que você tenha múltiplas posições do mesmo instrumento, incluindo em direções opostas.
Se, segundo um instrumento de negociação, existir uma posição aberta e o
trader executar uma nova transação (ou se estiver ativa uma ordem
pendente), ocorrerá a abertura de uma nova posição. A posição atual não
será alterada.
Abaixo mostramos um exemplo da execução de duas transações de compra de EURUSD com um volume de 0,5 lotes cada:
Como resultado da execução destas transações, temos a abertura de duas posições distintas.
Novo tipo de operação de negociação Close By
Para contas com
cobertura de registro de posições foi adicionado um novo tipo de
operação de negociação, isto é, o fechamento de uma posição usando uma
oposta. Esta operação permite fechar simultaneamente duas posições
opostas de um mesmo instrumento. Se as posições opostas tiverem
diferentes números de lotes, então, permanecerá aberta apenas uma das
duas. O seu volume será igual à diferença dos lotes de duas posições
fechadas, e a direção da posição e o preço de abertura serão iguais à
maior (em volume) das posições fechadas.
Em comparação com o fechamento individual de duas posições, o fechamento da oposta permite ao trader poupar um spread:
Ao fechar a posição usando outra oposta, estabelece-se uma ordem do tipo "close by". No seu comentário são indicados os bilhetes das posições fechadas. O fechamento de duas posições opostas ocorre usando duas transações do tipo "out by". O tamanho do lucro/perda total, obtido como resultado do fechamento de ambas as posições, é indicado apenas em uma transação.
class CAnimal { public: CAnimal(); // construtor virtual void Sound() = 0; // função virtual pura private: double m_legs_count; // número de patas do animalAqui a função Sound() é virtual pura, porque está declarada pelo especificador da função virtual PURE (=0).
class CAnimal { public: virtual void Sound()=NULL; // PURE method, deve ser redefinido no descendente, a mesma classe tornou-se abstrata e não pode ser criada }; //--- descendente da classe abstrata class CCat : public CAnimal { public: virtual void Sound() { Print("Myau"); } // PURE redefinido, a classe CCat não é abstrata e pode ser criada }; //--- exemplos de uso correto new CAnimal; // erro 'CAnimal' - o compilador emitirá o erro "cannot instantiate abstract class" CAnimal some_animal; // erro 'CAnimal' - o compilador emitirá o erro "cannot instantiate abstract class" //--- exemplos de uso correto new CCat; // não há erro - a classe CCat não é abstrata CCat cat; // não há erro - a classe CCat não é abstrataRestrições sobre o uso de classes abstratas
//+------------------------------------------------------------------+ //| Classe básica abstrata | //+------------------------------------------------------------------+ class CAnimal { public: //--- função virtual pura virtual void Sound(void)=NULL; //--- função void CallSound(void) { Sound(); } //--- construtor CAnimal() { //--- chamada direta do método virtual Sound(); //--- chamada indireta (através de una terceira função) CallSound(); //--- no construtor e/ou destrutor sempre são chamadas suas funções, //--- apesar do caráter virtual e da redefinição da função da chamada no descendente //--- se a função chamada for virtual pura, então, //--- a chamada provocará um erro crítico de execução: "pure virtual function call" } };No entanto, os construtores e destruidores de classes abstratas podem chamar outras funções membro.
typedef int (*TFunc)(int,int);Agora TFunc é um tipo e é possível declarar o indicador mutável para a função:
TFunc func_ptr;Na mutável func_ptr é possível armazenar o endereço da função para, no futuro, chamá-la:
int sub(int x,int y) { return(x-y); } int add(int x,int y) { return(x+y); } int neg(int x) { return(~x); } func_ptr=sub; Print(func_ptr(10,5)); func_ptr=add; Print(func_ptr(10,5)); func_ptr=neg; // erro: neg não tem tipo int (int,int) Print(func_ptr(10)); // erro: deve ter dois parâmetrosIndicadores para funções podem ser armazenados e transferidos como um parâmetro. É impossível obter um indicador para um método não estático de uma classe.
ulong PositionGetTicket( int index // número na lista de posições );
bool PositionSelectByTicket(
ulong ticket // bilhete da posição
);
Foi adicionado o link do vídeo tutorial video "Como criar um robô comercial no Master MQL5". Assista a este vídeo de três minutos e crie um robô comercial, sem escrever uma única linha de código.
2015.10.14 14:48:18.486 Data Folder: C:\Program Files\MetaTrader 5 2015.10.14 14:48:18.486 Windows 7 Professional (x64 based PC), IE 11.00, UAC, 8 x Intel Core i7 920 @ 2.67GHz, RAM: 8116 / 12277 Mb, HDD: 534262 / 753865 Mb, GMT+03:00 2015.10.14 14:48:18.486 MetaTrader 5 build 1190 started (MetaQuotes Software Corp.)
struct MqlTick { datetime time; // Tempo da última atualização do preço double bid; // Preço Bid em tempo real (atual) double ask; // Preço Ask em tempo real (atual) double last; // "Last" Preço em tempo real (último preço atual) ulong volume; // Volume do "Last" preço em tempo real (atual) long time_msc; // Tempo do "Last" preço atualizado em milissegundos uint flags; // Flags de tick };Os parâmetros de cada tick são preenchidos independentemente se existem alterações comparadas com o tick anterior. Assim, é possível descobrir o preço correto para qualquer momento no passado, sem a necessidade de procurar os valores anteriores do histórico do tick. Por exemplo, mesmo que apenas altere o preço Bid durante a chegada do tick, a estrutura ainda contém outros parâmetros, bem como incluindo o preço Ask anterior, volume, etc. Você pode analisar as flags dos ticks para descobrir quais dados foram alterados exatamente:
//+------------------------------------------------------------------+ //| TemplTest.mq5 | //| Copyright 2015, MetaQuotes Software Corp. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #property copyright "Copyright 2015, MetaQuotes Software Corp." #property link "https://www.mql5.com" #property version "1.00" //+------------------------------------------------------------------+ //| Declara uma classe template | //+------------------------------------------------------------------+ template<typename T> class TArray { protected: T m_data[]; public: bool Append(T item) { int new_size=ArraySize(m_data)+1; int reserve =(new_size/2+15)&~15; //--- if(ArrayResize(m_data,new_size,reserve)!=new_size) return(false); //--- m_data[new_size-1]=item; return(true); } T operator[](int index) { static T invalid_index; //--- if(index<0 || index>=ArraySize(m_data)) return(invalid_index); //--- return(m_data[index]); } }; //+------------------------------------------------------------------+ //| Classe template do array de ponteiro. No processo de destruição, | //| exclui os objetos que são os ponteiros armazenados no array. | //| | //| Por favor, note a herança do array da classe template | //+------------------------------------------------------------------+ template<typename T> class TArrayPtr : public TArray<T *> { public: void ~TArrayPtr() { for(int n=0,count=ArraySize(m_data);n<count;n++) if(CheckPointer(m_data[n])==POINTER_DYNAMIC) delete m_data[n]; } }; //+------------------------------------------------------------------------------+ //| Declarar a classe. Ponteiros aos respectivos objetos são armazenados no array| //+------------------------------------------------------------------------------+ class CFoo { int m_x; public: CFoo(int x):m_x(x) { } int X(void) const { return(m_x); } }; //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ TArray<int> ExtIntArray; // criar instância TArray (TArray especializada pelo tipo int) TArray<double> ExtDblArray; // criar instância TArray (TArray especializada pelo tipo double) TArrayPtr<CFoo> ExtPtrArray; // criar instância TArrayPtr (TArrayPtr especializada pelo tipo CFoo) //+------------------------------------------------------------------+ //| Função "Start" de Programa Script | //+------------------------------------------------------------------+ void OnStart() { //--- preencher o array com dados for(int i=0;i<10;i++) { int integer=i+10; ExtIntArray.Append(integer); double dbl=i+20.0; ExtDblArray.Append(dbl); CFoo *ptr=new CFoo(i+30); ExtPtrArray.Append(ptr); } //--- Saída do conteúdo do array string str="Int:"; for(int i=0;i<10;i++) str+=" "+(string)ExtIntArray[i]; Print(str); str="Dbl:"; for(int i=0;i<10;i++) str+=" "+DoubleToString(ExtDblArray[i],1); Print(str); str="Ptr:"; for(int i=0;i<10;i++) str+=" "+(string)ExtPtrArray[i].X(); Print(str); //--- Objetos CFoo criados via nova versão não deve ser suprimidos, uma vez que eles são excluídos no objeto destructor TArrayPtr <CFoo>}Resultado da execução:
int ObjectsDeleteAll( long chart_id, // ID de gráfico const string prefix, // prefixo do nome do objeto int sub_window=-1, // índice da janela int object_type=-1 // tipo de objeto para deletar );
Documentação atualizada.
A atualização estará disponível através do sistema LiveUpdate.
Agora, no Mercado, você pode comprar qualquer aplicativo num único passo, sem registro e diretamente a partir da plataforma MetaTrader 4/5. Para fazer isso, basta pressionar o botão "Comprar" e selecionar o sistema de pagamento adequado.
Em seguida, você será redirecionado para a página do sistema de pagamento, onde você poderá concluir a sua compra. Utilize PayPal, WebMoney, Neteller ou cartão de banco, pague de uma maneira familiar pelas suas compras na loja de robôs e indicadores prontos.
Após a compra, recomendamos registrar uma conta na MQL5.community, desse modo a sua compra ficará automaticamente ligada a ela. Assim, você poderá atualizar o produto e instalá-lo em outros computadores. Além disso, a conta MQL5.community dará acesso a uma variedade de outros serviços para plataformas MetaTrader, a saber: sinais de negociação para copiar transações de traders bem sucedidos, hospedagem virtual para funcionamento ininterrupto dos seus aplicativos e o serviço freelance para encomendar robôs exclusivos aos desenvolvedores.
Agora você sabe qual é a maneira mais fácil e mais rápida para obter um robô de negociação. Mais de 5 000 aplicativos diferentes para MetaTrader já estão à sua espera no Mercado, escolha e compre!