1 abril 2016
1 abril 2016
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
);