Fragen zu OOP in MQL5 - Seite 68

Neuer Kommentar
 
Dmitry Fedoseev:

Und warum? Ein anderes Muster. Nur haben die Anhänger des Musters es nicht anerkannt, offenbar nicht orthodox, nicht kanonisch. Warum nicht Rekursion? Auch Rekursion, nur nicht entlang, sondern quer.

Igor beschwerte sich lediglich darüber, dass er zwei Zyklen hat und das Wunder nicht in einen einzigen packen kann.
Da fiel mir diese Website mit einem Beispiel ein, vielleicht kann ich ja ganz ohne Schleifen auskommen. Und ein Wunder kann geschehen ))
Und so schlug ich diese Variante vor, um darüber nachzudenken )) vielleicht wird es ohne Schleifen funktionieren.
Und die Tatsache, dass jemand was nicht nach der Religion ist, ist eine Sache von jedem.

 
Roman:

Igor hat sich nur darüber beschwert, dass er zwei Schleifen bekommen hat und ein Wunder nicht in eine Schleife packen konnte.

Ich habe mich nicht beschwert, ich habe versucht, die Geheimnisse der Programmierer zu lernen :)

Ich kann es tun, ich kann eine Schleife mit Rekursion verpacken (ersetzen) - wenn es helfen würde :)

Roman:

Was nicht religiös ist, geht jeden etwas an.

Es geht nicht um Religion, sondern darum zu verstehen, dass es bewährte Programmierpraktiken gibt, und wenn die meisten Leute diese Praktiken anwenden, bedeutet das, dass sie effektiv sind - effektiv in Bezug auf Geschwindigkeit, effektiv in Bezug auf die Lesbarkeit des Codes, effektiv in Bezug auf die weitere Wartung, effektiv in Bezug auf die Wiederverwendung...

und Religion? Imho geht es beim Know-how in der Programmierung in der Regel darum, das Material (oder die Informationen) nicht zu besitzen und diese "Harken" dann als eigene Innovation zu verbreiten

 
Igor Makanu:

Ich habe mich nicht beschwert, sondern versucht, die Geheimnisse der Programmierer zu erfahren :)

Ich kann es tun, ich kann auch Rekursion verwenden, wenn es helfen würde :)

Es geht nicht um Religion, sondern um die Vorstellung, dass es bewährte Programmierpraktiken gibt, und wenn die meisten Leute sie anwenden, bedeutet das, dass sie effizient sind - effizient in Bezug auf Geschwindigkeit, effizient in Bezug auf die Lesbarkeit des Codes, effizient in Bezug auf die weitere Wartung, effizient in Bezug auf die Wiederverwendung...

Und Religion? Imho geht es beim Know-how in der Programmierung in der Regel darum, das Material (oder die Informationen) nicht zu besitzen und diese "Harken" dann als eigene Innovation zu verbreiten.

In einem Beispiel wird erwähnt, dass das Beispiel ein Metaprogrammierungsmuster verwendet.
Mit Hilfe von Schablonen ist es möglich, Programme zu schreiben, die zur Kompilierzeit Berechnungen durchführen, sofern dies der Aufgabe entspricht.
Solche Programme werden als Schablonenmetaprogramme bezeichnet.
Das Terminal heißt nicht umsonst MetaTrader.
;))

 
Igor Makanu:

Ich habe mich nicht beschwert, sondern versucht, die Geheimnisse der Programmierer zu erfahren :)

Ich kann es tun, ich kann auch Rekursion verwenden, wenn es helfen würde :)

Es geht nicht um Religion, sondern um die Vorstellung, dass es bewährte Programmierpraktiken gibt, und wenn die meisten Leute sie anwenden, bedeutet das, dass sie effizient sind - effizient in Bezug auf Geschwindigkeit, effizient in Bezug auf die Lesbarkeit des Codes, effizient in Bezug auf die weitere Wartung, effizient in Bezug auf die Wiederverwendung...

Und Religion? Imho ist es Know-how in der Programmierung, normalerweise ist es nicht der Besitz des Materials (oder der Informationen) und dann die Verbreitung dieser "Harken" als Ihre eigene Innovation

Igor, ich konnte heute Morgen nicht widerstehen und zeichnete auf meinem Knie einen Aufruf von beliebigen Methoden ohne Schleifen. Nur für den Fall, dass es wirklich nützlich sein könnte. *Vorsichtig, SB verwendet :))

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

Und warum? Ein anderes Muster. Nur haben die Anhänger des Musters es nicht anerkannt, offenbar nicht orthodox, nicht kanonisch. Warum nicht Rekursion? Es handelt sich auch um eine Rekursion, nur nicht in Längsrichtung, sondern in Querrichtung.

Dies wird "Schleifenabwicklung" genannt und wird vom Compiler ohne OO und Vorlagen durchgeführt (zumindest sollte dies so sein).

Wenn man sich den Zwischencode (Assembler) ansieht, gibt es statt einer Schleife nur N Operationen hintereinander.

 
Ich habe ein unerwartetes Ergebnis erhalten.
#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:
Ich habe ein unerwartetes Ergebnis erhalten.


Was sind dieAbmessungen der Strukturen über sizeof, weil ich nicht am Computer bin?
 
Vladimir Simakov:
Was ist die Größe von Strukturen über sizeof, weil ich nicht am Computer bin?
        : sizeof(STRUCT1) = 20
        : sizeof(STRUCT2) = 16

Je größer die einfache Struktur ist, desto langsamer wird sie bearbeitet.

 
fxsaber:

Je größer die einfache Struktur ist, desto langsamer wird sie bearbeitet.

Erstellen Sie die erste Struktur {int;int;double[2]}
 
Vladimir Simakov:
Erstellen Sie die erste Struktur {int;int;double[2]}
        Alert: Time[Test6.mq5 285: Func(Array1)] = 378 ms.
        Alert: Time[Test6.mq5 286: Func(Array2)] = 156 ms.
Die Ausrichtung hat damit nichts zu tun. Ich habe das sofort überprüft.
1...616263646566676869707172737475...96
Neuer Kommentar