FórumSeções

Perguntas sobre OOP em MQL5 - página 68

Novo comentário
Dmitry Fedoseev:

Por quê? Outro padrão. Exceto que os adeptos dos padrões não o reconheceram, aparentemente não ortodoxos, não canônicos. Por que não a recorrência? Também recorrência, apenas não ao longo, mas transversalmente.

Igor simplesmente reclamou que ele tem dois ciclos e não pode amontoar o milagre em um só.
Então, eu me lembrei deste site com um exemplo, talvez eu possa prescindir de loops. E um milagre pode acontecer ))
E assim sugeri esta variante para pensar )) talvez funcione sem loops.
E o fato de que alguém que não está de acordo com a religião, é uma questão de cada um.

Roman:

Igor estava apenas reclamando que recebeu duas voltas e não conseguiu enfiar um milagre em uma volta.

Eu não estava reclamando, eu estava tentando aprender os segredos dos programadores :)

Posso fazer isso, posso embrulhar (substituir) um laço com repetição - se isso ajudar :)

Romano:

O que não é religioso é um assunto de todos.

Não se trata de religião, mas de entender que existem práticas de programação bem estabelecidas e se a maioria das pessoas usa essas práticas, isso significa que elas são eficazes - eficazes em termos de velocidade, eficazes em termos de legibilidade do código, eficazes em termos de manutenção posterior, eficazes em termos de reutilização...

e religião? imho, o know-how em programação é geralmente sobre não possuir o material (ou informação) e depois divulgar esses "ancinhos" como sua própria inovação

Igor Makanu:

Eu não estava reclamando, eu estava tentando aprender os segredos dos programadores :)

Posso fazer isso, também posso usar a recorrência, se isso ajudar :)

Não se trata de religião, mas da idéia de que existem práticas de programação bem estabelecidas e se a maioria das pessoas as utiliza, isso significa que são eficientes - eficientes em termos de velocidade, eficientes em termos de legibilidade do código, eficientes em termos de manutenção posterior, eficientes em termos de reutilização...

E religião? imho, know-how em programação é geralmente sobre não possuir o material (ou informação) e depois espalhar esses "ancinhos" como sua própria inovação

Um exemplo menciona que o exemplo utiliza um padrão de metaprogramação.
Usando modelos, é possível escrever programas que realizam cálculos em tempo de compilação, desde que seja conveniente para a tarefa.
Tais programas são chamados de metaprogramas de modelos.
O terminal é chamado MetaTrader por uma razão.
;))

Igor Makanu:

Eu não estava reclamando, eu estava descobrindo os segredos dos programadores :)

Posso fazer isso, também posso usar a recorrência, se isso ajudar :)

Não se trata de religião, mas da idéia de que existem práticas de programação bem estabelecidas e se a maioria das pessoas as utiliza, isso significa que são eficientes - eficientes em termos de velocidade, eficientes em termos de legibilidade do código, eficientes em termos de manutenção posterior, eficientes em termos de reutilização...

E religião? imho, know-how em programação, geralmente não é dono do material (ou informação) e depois espalhar esses "ancinhos" como sua própria inovação

Igor, eu não pude resistir esta manhã e me ajoelhei com uma chamada de qualquer método sem loops. Só para o caso de ser realmente útil. *Cautelosamente, SB utilizado :))

#include <Arrays\List.mqh>
//+------------------------------------------------------------------+
class base : public CObject
  {
public:
   virtual void      HighPriorityTask() {}
   virtual void      Task() {}
  };
//+------------------------------------------------------------------+
class A: public base
  {
private:
   static            A*lastnode;
   static            A*rootnode;
   static int        ID_counter;

public:
   int               ID;
                     A()
     {
      Prev((CObject*)lastnode);
      A*self = GetPointer(this);
      if(lastnode)
         lastnode.Next(self);
      lastnode=self;
      if(rootnode==NULL)
         rootnode=self;
      ID=ID_counter++;
     }
   static  A*        GetRoot() {return rootnode;}

   virtual void      HighPriorityTask() { Print(__FUNCSIG__," ID=",ID); A* next=(A*)Next(); if(next!=NULL) next.HighPriorityTask(); }
  };
A* A::rootnode=NULL;
A* A::lastnode=NULL;
int A::ID_counter=0;
//+------------------------------------------------------------------+
class B: public base
  {
public:
   virtual void      Task() { Print(__FUNCSIG__); }
  };

//+------------------------------------------------------------------+
void OnStart()
  {
   base *obj[4];;
   obj[0] = new A;
   obj[1] = new A;
   obj[2] = new B;
   obj[3] = new B;
   A* arr[5];
   for(int i=0; i<5; i++)
     {
      arr[i]= new A();
     }
   if(A::GetRoot()!=NULL)
      A::GetRoot().HighPriorityTask();
   for(int i=ArraySize(obj)-1; i>=0; i--)
     {
      //obj[i].HighPriorityTask();
      obj[i].Task();
     }

   for(int i=ArraySize(obj)-1; i>=0; i--)
      delete obj[i];
   for(int i=0; i<5; i++)
     {
      delete arr[i];
     }
  }
//+------------------------------------------------------------------+
Dmitry Fedoseev:

Por quê? Outro padrão. Exceto que os adeptos dos padrões não o reconheceram, aparentemente não ortodoxos, não canônicos. Por que não a recorrência? É também uma recorrência, não apenas longitudinal, mas transversalmente.

É chamado "loop unrolling" e é feito pelo compilador sem qualquer OO e modelos (pelo menos deveria ser).

Se você olhar para o código intermediário (assembler), há apenas N operações em uma fila em vez de um loop.

Obteve um resultado inesperado.
#include <fxsaber\Benchmark.mqh> // https://c.mql5.com/3/321/Benchmark.mqh

// Простая структура.
struct STRUCT1
{
  int i;  
  double j[2];
};

// Сложная структура.
struct STRUCT2
{
  int i;  
  string Str;
  
  STRUCT2() : Str("1234567 1234567")
  {
  }
};

template <typename T>
int Func( T &Array[] )
{  
  // Write
  for (int i = ArraySize(Array) - 1; i >= 0; i--)
    Array[i].i = i;

  int Sum = 0;
  
  // Read
  for (int i = ArraySize(Array) - 1; i >= 0; i--)
    Sum += Array[i].i;
    
  return(Sum + ArraySize(Array));    
}

void OnStart()
{
  STRUCT1 Array1[]; // Простая структура.
  STRUCT2 Array2[]; // Сложная структура.
  
  const int Amount = 5 e7;
  
  Print(_B(ArrayResize(Array1, Amount), 1));
  Print(_B(ArrayResize(Array2, Amount), 1));
    
  Print(_B(Func(Array1), 1)); // Чтение и запись простой структуры происходит в разы дольше,
  Print(_B(Func(Array2), 1)); // чем сложной.
}


        50000000
        Alert: Time[Test6.mq5 280: ArrayResize(Array2,Amount)] = 640 ms.
        50000000
        Alert: Time[Test6.mq5 282: Func(Array1)] = 440 ms.
        1333106752
        Alert: Time[Test6.mq5 283: Func(Array2)] = 156 ms.
        1333106752
fxsaber:
Obteve um resultado inesperado.


Quais são asdimensões das estruturas via sizeof, porque eu não estou no computador?
Vladimir Simakov:
Qual é o tamanho das estruturas via sizeof, porque eu não estou no comp?
        : sizeof(STRUCT1) = 20
        : sizeof(STRUCT2) = 16

Quanto maior o tamanho da estrutura simples, mais lenta é a sua manipulação.

fxsaber:

Quanto maior o tamanho da estrutura simples, mais lenta é a sua manipulação.

fazer a primeira estrutura {int;int;double[2]}
Vladimir Simakov:
fazer a primeira estrutura {int;int;double[2]}
        Alert: Time[Test6.mq5 285: Func(Array1)] = 378 ms.
        Alert: Time[Test6.mq5 286: Func(Array2)] = 156 ms.
O alinhamento não tem nada a ver com isso. Eu verifiquei isso imediatamente.
1...616263646566676869707172737475...96
Novo comentário