Domande su OOP in MQL5 - pagina 68

Nuovo commento
 
Dmitry Fedoseev:

Perché? Un altro modello. Solo che gli aderenti ai modelli non lo riconoscevano, apparentemente non ortodosso, non canonico. Perché non la ricorsione? Anche la ricorsione, solo non lungo, ma attraverso.

Igor si è semplicemente lamentato del fatto che ha due cicli e non può stipare il miracolo in uno solo.
Così, mi sono ricordato di questo sito web con un esempio, forse posso fare a meno dei loop. E un miracolo può accadere ))
E così ho suggerito questa variante per pensare :) forse funzionerà senza loop.
E il fatto che qualcuno cosa non è secondo la religione, è una questione di ciascuno.

 
Roman:

Igor si stava solo lamentando del fatto che aveva due loop e non poteva stipare un miracolo in un solo loop.

Non mi stavo lamentando, stavo cercando di imparare i segreti dei programmatori :)

Posso farlo, posso avvolgere (sostituire) un ciclo con la ricorsione - se può aiutare :)

Romano:

Ciò che non è religioso è affare di tutti.

Non si tratta di religione ma di capire che ci sono pratiche di programmazione consolidate e se la maggior parte delle persone usa queste pratiche, significa che sono efficaci - efficaci in termini di velocità, efficaci in termini di leggibilità del codice, efficaci in termini di ulteriore manutenzione, efficaci in termini di riutilizzo...

e la religione? imho, il know-how nella programmazione di solito consiste nel non possedere il materiale (o le informazioni) e poi diffondere questi "rastrellamenti" come la propria innovazione

 
Igor Makanu:

Non mi stavo lamentando, stavo cercando di imparare i segreti dei programmatori :)

Posso farlo, posso anche usare la ricorsione, se può aiutare :)

Non si tratta di religione ma dell'idea che ci sono pratiche di programmazione consolidate e se la maggior parte delle persone le usa, significa che sono efficienti - efficienti in termini di velocità, efficienti in termini di leggibilità del codice, efficienti in termini di ulteriore manutenzione, efficienti in termini di riutilizzo...

E la religione? imho, il know-how nella programmazione di solito consiste nel non possedere il materiale (o le informazioni) e poi diffondere questi "rastrellamenti" come innovazione propria

Un esempio menziona che l'esempio usa un modello di metaprogrammazione.
Usando i template, è possibile scrivere programmi che eseguono calcoli a tempo di compilazione, purché sia adatto al compito.
Tali programmi sono chiamati metaprogrammi template.
Il terminale si chiama MetaTrader per una ragione.
;))

 
Igor Makanu:

Non mi stavo lamentando, stavo cercando di imparare i segreti dei programmatori :)

Posso farlo, posso anche usare la ricorsione, se può aiutare :)

Non si tratta di religione ma dell'idea che ci sono pratiche di programmazione consolidate e se la maggior parte delle persone le usa, significa che sono efficienti - efficienti in termini di velocità, efficienti in termini di leggibilità del codice, efficienti in termini di ulteriore manutenzione, efficienti in termini di riutilizzo...

E la religione? imho, il know-how nella programmazione, di solito non è possedere il materiale (o le informazioni) e poi diffondere questi "rastrellamenti" come innovazione propria

Igor, non ho potuto resistere questa mattina e ho disegnato sul mio ginocchio una chiamata di qualsiasi metodo senza loop. Solo nel caso in cui possa davvero tornare utile. *Precauzioni, SB usato :))

#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:

Perché? Un altro modello. Solo che gli aderenti ai modelli non lo riconoscevano, apparentemente non ortodosso, non canonico. Perché non la ricorsione? È anche una ricorsione, solo non longitudinalmente, ma trasversalmente.

Si chiama "loop unrolling" ed è fatto dal compilatore senza OO e template (almeno dovrebbe essere così).

Se guardate il codice intermedio (assembler), ci sono solo N operazioni in fila invece di un ciclo.

 
Ho ottenuto un risultato inaspettato.
#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:
Ho ottenuto un risultato inaspettato.


Quali sono ledimensioni delle strutture tramite sizeof, perché non sono al computer?
 
Vladimir Simakov:
Qual è la dimensione delle strutture tramite sizeof, perché non sono al computer?
        : sizeof(STRUCT1) = 20
        : sizeof(STRUCT2) = 16

Più grande è la dimensione della struttura semplice, più lento è il trattamento.

 
fxsaber:

Più grande è la dimensione della struttura semplice, più lento è il trattamento.

rendere la prima struttura {int;int;double[2]}
 
Vladimir Simakov:
rendere la prima struttura {int;int;double[2]}
        Alert: Time[Test6.mq5 285: Func(Array1)] = 378 ms.
        Alert: Time[Test6.mq5 286: Func(Array2)] = 156 ms.
L'allineamento non c'entra niente. L'ho controllato subito.
1...616263646566676869707172737475...96
Nuovo commento