Perguntas sobre OOP em MQL5 - página 21

Novo comentário
 
Alexey Navoykov:
Esta é uma classe puramente de teste ou você realmente vai usá-la?
Se é o último, não se deve fazer isso. As variáveis estáticas não são reinicializadas quando um personagem muda, pelo que me lembro.
E, em geral, não é uma boa idéia inicializar estáticas constantes com valores externos, que não estão necessariamente disponíveis no momento da inicialização.

Osegundo, estou escrevendo de qualquer forma no MT4, mesmo para mim mesmo - não funciona no testador por alguns símbolos, se eu vejo algo útil no MT4, eu vou mudar para o MT5 usando o MT4Orders - eu verifiquei meu "trabalho criativo" sem problemas com esta biblioteca

primeiro, quero ver a idéia de um OOP adequado - é por isso que estou testando, para ver o que vai sair, até agora está indo muito mal.... veremos, tenho tempo, aqui está o carregador que decidi fazer eu mesmo ))))


sei que não é a melhor maneira de inicializar antes do início do código principal, ou melhor, eu pensava assim, mas nunca o verifiquei, não importa quantas novas construções eu tivesse - na MQL tudo está sempre disponível, mesmo em nível de visibilidade global, vi as fontes que as pessoas vão diretamente ao topo e as escrevem dessa maneira:

#property strict
int    dig = _Digits;
double point = _Point;
double startbalance = AccountBalance();

e estas inicializações inválidas vêm trabalhando há anos de construção em construção. Assim, os desenvolvedores estragaram as pessoas até o osso ))))




SZZY: aqui em geral, como sempre quando se usa OOP - o principal é dividir corretamente o problema em elementos complexos e não herdar de tudo o que está à mão. Eu não sei onde "colar" erros de saída de texto - deve estar em toda parte, em qualquer classe e em qualquer lugar do programa, muito provavelmente você terá que criar uma classe base como@Vladimir Simakov mostrou acima de seu código

 
Igor Makanu:

pp 1-3 todos solvíveis, MAS... OK, aqui com estática ajudou, que assim seja porque há uma ajuda, pelo menos algo para justificar sua decisão, agora o código é o seguinte:

criou 3 instâncias do Cdeal, entrou no log:

...

até agora tudo está funcionando como pretendido!

Mesmo que funcione, não é confiável. Como a função é implementada fora da classe, é difícil controlar a ordem dos campos na própria classe. Você deve ao menos escrever um comentário ousado na classe dizendo que tais e tais campos não devem ser rearranjados). Mas sua variante inicial era melhor de qualquer forma. Você não deve sacrificar a segurança para salvar uma linha de código )
 
Alexey Navoykov:
Mas, mesmo assim, sua versão original era melhor. Não sacrifique a confiabilidade para salvar uma linha de código )

Qual deles? - Tenho metade do tópico em minhas variações ))))

mas sim, você está cem por cento certo!

SZY:

a maneira mais simples e confiável - criar uma instância da classe via nova no OnInit() - e copiar todas as variáveis do ambiente terminal imediatamente, mas não é a melhor maneira - se eu planejo abrir uma ordem imediatamente na inicialização do construtor neste exemplo, então esta instância da classe provavelmente será apagada e então possivelmente recriada - isto já traz alguns problemas por causa de chamadas repetidas - eu começo a carregar o terminal novamente, novamente desperdiçando memória.... em geral, não é solvível desta forma


ZZZY: talvez mais um dia de experimentos, e eventualmente tomar@Vladimir Simakov exemplo - tudo é muito claro lá

 
Igor Makanu:

Eu esbocei minha classe, que deveria inicializar os campos uma vez com valores constantes, e parece funcionar como pretendido:

Eu não gosto de 2 coisas:

1. repito a chamada SymbolInfoDouble(_Symbol,SYMBOL_VOLUME_STEP) - porque a ordem de inicialização não está definida, ou seja, não é certo que o VolumeSTEP será inicializado primeiro e só então GetDigitsInVolumeStep() será chamado

2. quero me livrar do método estático no GetDigitsInVolumeStep() - Vi um vídeo no youtube dizendo que no OOP puro não se deve usar métodos estáticos, e agora estou lutando contra moinhos de vento

o link para o vídeo, é essencialmente o mesmohttps://youtu.be/lfdAwl3-X_c ehttps://youtu.be/zME4SOCHT0I


como posso reescrever estes 2 pontos que não me agradam?

1. Não há nada de errado em chamar esta função duas vezes.

2) Não o confunde que aqueles que são contra o uso de funções estáticas não dão o menor argumento?

É melhor não assistir a vídeos de qualquer pessoa, mas ler livros.

 
Koldun Zloy:

2. Você não está confundido que aqueles que são contra o uso de funções estáticas não dão o menor argumento?

E você é o primeiro a me apoiar que o vídeo não corresponde a nada da prática, eu escrevi em outro fio minha opinião sobre o vídeo - o palestrante não pôde nem mesmo responder as perguntas dos alunos

 
Igor Makanu:

e você é o primeiro a me apoiar que o vídeo não corresponde a nada da prática, escrevi em outro tópico minha opinião sobre o vídeo - o repórter não pôde nem mesmo responder as perguntas dos alunos

Eu não acho que o OOP seja sobre cortar as próprias capacidades para seguir cegamente os postulados infundados de alguns bocais da Internet, onde todos varrem à sua própria maneira.

 
Artyom Trishkin:

Não creio que o OOP seja a redução das próprias capacidades para seguir cegamente os postulados infundados de alguns bocais da Internet, onde cada um varre à sua maneira.

se você já viu o vídeo, você deve entender que o alvo é .... bem, em geral, você também não entende nada e ainda não está maduro o suficiente - pelo menos foi assim que o A100 me explicou

SZZ: Experimentarei um pouco mais tarde com interfaces, talvez surjam algumas "entidades-instituições" ))))

 

Eu vi seu vídeo sobre estática, tudo por causa de escrever assim:

new Type0(new Type1(new Type2(...)));

Bem, escrever uma embalagem por cima de uma estática é um problema, não é?

class Stateless_with_state {
        Stateless q;
        Data d;
        call() {q::call(d);}
};

E, através de modelos, são claramente mais eficientes. Gostei da pergunta do público https://www.youtube.com/watch?v=75U9eefFYoU#t=33m25s

 
Igor Makanu:

ZS: Experimentarei interfaces um pouco mais tarde, talvez apareça alguma "entidade-instituição" ))))

Verificado se "Padrão OOP - Padrões de comportamento - Estratégia" vai funcionar

interface IStrategy
  {
   void Algorithm();
  };
//+------------------------------------------------------------------+
class Strategy_1 : public IStrategy
  {
public:
                     Strategy_1()   {Print(__FUNCTION__);}
   void              Algorithm()    {Print(__FUNCTION__);}
  };
//+------------------------------------------------------------------+
class Strategy_2 : public IStrategy
  {
public:
                     Strategy_2()   {Print(__FUNCTION__);}
   void              Algorithm()    {Print(__FUNCTION__);}
  };
//+------------------------------------------------------------------+
class Context
  {
private:
   IStrategy         *s;
public:
                     Context(IStrategy &_strategy) {Print(__FUNCTION__); s = GetPointer(_strategy); s.Algorithm();}
                    ~Context() {delete s;}
  };
//+------------------------------------------------------------------+
void OnStart()
  {
   Context c1(new Strategy_1);
   Context c2(new Strategy_2);
  }
//+------------------------------------------------------------------+

2019.08.31 21:04:40.441 tst (EURUSD,H1) Strategy_1::Strategy_1

2019.08.31 21:04:40.442 tst (EURUSD,H1) Contexto::Contexto

2019.08.31 21:04:40.442 tst (EURUSD,H1) Strategy_1::Algorithm

2019.08.31 21:04:40.442 tst (EURUSD,H1) Strategy_2::Strategy_2

2019.08.31 21:04:40.442 tst (EURUSD,H1) Contexto::Contexto

2019.08.31 21:04:40.442 tst (EURUSD,H1) Strategy_2::Algorithm


Funciona sem nenhum problema em minha opinião

 
Igor Makanu:

verificou se o "Padrão OOP - Padrões de Comportamento - Estratégia (Estratégia)" vai funcionar

2019.08.31 21:04:40.441 tst (EURUSD,H1) Strategy_1::Strategy_1

2019.08.31 21:04:40.442 tst (EURUSD,H1) Contexto::Contexto

2019.08.31 21:04:40.442 tst (EURUSD,H1) Strategy_1::Algorithm

2019.08.31 21:04:40.442 tst (EURUSD,H1) Strategy_2::Strategy_2

2019.08.31 21:04:40.442 tst (EURUSD,H1) Contexto::Contexto

2019.08.31 21:04:40.442 tst (EURUSD,H1) Strategy_2::Algorithm


funciona sem nenhum problema para mim

Context(IStrategy* _strategy):s(_strategy){Print(__FUNCTION__); s.Algorithm();}

O novo operador devolve um ponteiro. É claro que os desenvolvedores fizeram asneira com o desreferenciamento implícito e é por isso que sua versão funciona, mas prefiro não ficar preso a coisas não documentadas.

2. Certamente não é C++, mas é muito semelhante, então as listas de inicialização (eu não sei sobre eficiência) são kosher.

1...141516171819202122232425262728...96
Novo comentário