Perguntas sobre OOP em MQL5 - página 36

Novo comentário
 
Igor Makanu:

Bem sim, essa é uma solução melhor! para que haja um método a menos

Deve haver apenas uma novidade no OnStart.
 
Koldun Zloy:

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

2. você não se importa que aqueles que são contra o uso de funções estáticas não dêem o menor argumento?

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

Desejo ao autor dos vídeos https://youtu.be/lfdAwl3-X_c e https://youtu.be/zME4SOCHT0I muitas coisas boas..... nocauteadas a semana inteira, tudo o que eu sento para fazer eu começo a pensar, não fazendo como antes .... você não pode usar estática, não é OOP!

Eu quero terminar o código, tenho uma pergunta:

- Eu quero salvar campos de objetos, bom, os campos foram imediatamente colocados nas estruturas, e você pode salvá-los com um único clique através de FileWriteStruct()

- há N objetos de uma classe, todos herdados de uma classe base

- porque assisti ao vídeo, esperava que algum método me ajudasse a não interrogar cada objeto se precisasse salvar o arquivo.... Em geral, fiasco, foi decidido não ser tolo e criar um método que irá estaticamente atribuir uma bandeira para escrever no arquivo

class CStrategy: public IStrategy
{
protected:
static bool       f_save_required;
void              SetSaveRequired()        { CStrategy::f_save_required = true;                    }
public:
bool              GetSaveRequired()        { return(CStrategy::f_save_required);                   }

Funciona como planejado

E a pergunta em si, o que acontecerá se você a escrever desta maneira:

class CStrategy: public IStrategy
{
private:
static bool       f_save_required;
protected:
void              SetSaveRequired()        { CStrategy::f_save_required = true;                    }
public:
bool              GetSaveRequired()        { return(CStrategy::f_save_required);                   }

o que acontecerá se você o escrever desta maneira:

class CStrategy: public IStrategy
{
private:
static bool       f_save_required;
protected:
void              SetSaveRequired()        { f_save_required = true;                    }
public:
bool              GetSaveRequired()        { return(f_save_required);                   }
 

tentei diferentes maneiras de modificar o roteiro de teste, não consigo ver nenhuma diferença, mostre-me os modificadores corretos para o post acima: (protegido / privado ) e ligue para M::x ou apenas x

//+------------------------------------------------------------------+
interface I
{  bool main();

};
//+------------------------------------------------------------------+
class M:public I
{
protected:
static int        x;
bool              main()   { x++;  Print(__FUNCTION__," = ",x); return(x>0); }
public:
                     M()      { Print(__FUNCTION__);}
                    ~M()      { Print(__FUNCTION__);}
};
//+------------------------------------------------------------------+

static int M::x=0;
//+------------------------------------------------------------------+
class A:public M
{
public:
                     A()      { Print(__FUNCTION__);}
                    ~A()      { Print(__FUNCTION__);} };
//+------------------------------------------------------------------+
class B:public M
{
public:
                     B()      { Print(__FUNCTION__);}
                    ~B()      { Print(__FUNCTION__);} };
//+------------------------------------------------------------------+
class C:public M
{
public:
                     C()      { Print(__FUNCTION__);}
                    ~C()      { Print(__FUNCTION__);} };
//+------------------------------------------------------------------+

void OnStart()
{  I *a = new A;
   I *b = new B;
   I *c = new C;
   I *m = new M;

   a.main();
   b.main();
   c.main();
   m.main();


   delete a;
   delete b;
   delete c;
   delete m;

}
//+------------------------------------------------------------------+
 
Igor Makanu:

tentei diferentes maneiras de modificar o roteiro de teste, não consigo ver nenhuma diferença, mostre-me os modificadores corretos para o post acima: (protegido / privado ) e ligue para M::x ou apenas x

Dentro dos métodos de classe você chama x, em todos os outros lugares M::x. Se protegido, então a referência só é possível nos métodos da classe na qual o campo é definido, aqui a lógica é comum.
 
Feliz feriado, a propósito. Outro byte aconteceu.
 
Vladimir Simakov:
Dentro dos métodos de classe você chama x, em todos os outros lugares M::x, se protegido, então o acesso é possível somente nos métodos da classe na qual o campo é definido, aqui a lógica é comum.

Certo! Eu fiz um exemplo errado durante o sono, então eu recebi 'M::main' - não posso acessar a função de membro privado:

class M
{
private:
   static int        x;
   bool              main()   { x++;  Print(__FUNCTION__," = ",x); return(x>0); }
public:
                     M()      { Print(__FUNCTION__);}
                    ~M()      { Print(__FUNCTION__);} };
//+------------------------------------------------------------------+

static int M::x=0;
//+------------------------------------------------------------------+
class A:public M
{
public:
                     A()      { Print(__FUNCTION__);}
                    ~A()      { Print(__FUNCTION__);}
   void                inc()     {main();} };
//+------------------------------------------------------------------+
class B:public M
{
public:
                     B()      { Print(__FUNCTION__);}
                    ~B()      { Print(__FUNCTION__);}
   void                inc()     {main();} };
//+------------------------------------------------------------------+
class C:public M
{
public:
                     C()      { Print(__FUNCTION__);}
                    ~C()      { Print(__FUNCTION__);}
   void                inc()     {main();} };
//+------------------------------------------------------------------+
void OnStart()
{  A *a = new A;
   B *b = new B;
   C *c = new C;
   M *m = new M;

   a.inc();



   delete a;
   delete b;
   delete c;
   delete m;

}
//+------------------------------------------------------------------+

tem 'M::main' - não pode acessar a função de membro privado tst.mq5 25 32

Se eu anotar

protected:   
   bool              main()   { x++;  Print(__FUNCTION__," = ",x); return(x>0); }

tudo funciona como planejado!

 
Vladimir Simakov:
Feliz feriado, a propósito. Outro byte aconteceu.

Obrigado, está ordenado!

Boas Festas!

 
Igor Makanu:

Desejo ao autor dos vídeos https://youtu.be/lfdAwl3-X_c e https://youtu.be/zME4SOCHT0I muitas coisas boas..... nocauteadas a semana toda, tudo o que eu sento para fazer eu começo a pensar em vez de fazer como antes .... você não pode usar estática, não é OOP!

Eu quero terminar o código, tenho uma pergunta:

- Eu quero salvar campos de objetos, bom, os campos foram imediatamente colocados nas estruturas, e você pode salvá-los com um único clique através de FileWriteStruct()

- há N objetos de uma classe, todos herdados de uma classe base

- porque assisti ao vídeo, esperava que algum método me ajudasse a não interrogar cada objeto se precisasse salvar o arquivo.... Em geral, fiasco, foi decidido não ser tolo e criar um método que irá estaticamente atribuir uma bandeira para escrever no arquivo

Funciona como planejado

E a pergunta em si, o que acontecerá se você a escrever desta maneira:

o que acontece se você escrever desta maneira:

De que depende se um objeto precisa ser salvo em um arquivo?

Esta bandeira é comum para todos os objetos?

 
Koldun Zloy:

Do que depende para salvar o objeto em um arquivo?

Esta é uma característica comum a todos os objetos?

Bem, a questão é dialética, é claro, aqui

- É melhor ter 10 estratégias e escrever 10 arquivos com mudança de estado de TC (1 TC = 1 estrutura)

- ou é mais lógico passar um cabo da classe, onde há uma chamada (busca) de estratégias por carrapato, de modo que todos eles escrevem em um arquivo

Acho que a 2ª variante é mais lógica


acontece que após o início de todos os TCs você precisa escrever 10 estruturas uma vez - o estado mudou

então em ordem aleatória eles precisam escrever quando necessário ( acionamento do SL ou TP) - aqui também é mais rápido abrir o arquivo e escrever 10 estruturas de uma só vez, as estratégias não são direcionadas por pipswise, nem a cada segundo, de um minuto a uma hora em cada TS


Até agora, eu implementei uma descrição de uma variável estática e acesso a ela através de um get - set, set protegido, get public - ela também é redefinida para falsificar a variável estática após a chamada

 
Igor Makanu:

Bem, a questão é dialética, é claro, aqui

- Você tem 10 estratégias e escreve 10 arquivos com mudança de estado de TC (1 TC = 1 estrutura)

- ou é mais lógico passar um cabo da classe, onde há uma chamada (busca) de estratégias em um tick, de modo que eles escrevem tudo em um arquivo

Acho que a 2ª variante é mais lógica


acontece que após o início de todos os TCs você precisa escrever 10 estruturas uma vez - o estado mudou

então em ordem aleatória eles precisam escrever quando necessário ( SL ou TP disparo) - aqui também é mais rápido abrir o arquivo e escrever 10 estruturas de uma só vez, as estratégias não são pipswise, nem a cada segundo, de um minuto a uma hora em cada TS


Por enquanto, eu implementei através da descrição de uma variável estática de acesso a ela via get - set, set protected, get public - ela também repõe a variável estática em falso após ter sido chamada

Tudo isso está claro. Não está claro porqueSetSaveRequired() eGetSaveRequired() não são estáticos, mas escrevem para uma variável estática.

1...293031323334353637383940414243...96
Novo comentário