MQL5中的OOP问题 - 页 68

[Roman]

Dmitry Fedoseev:

为什么？另一种模式。除了模式的信徒不承认它，显然不是正统的，不是典范的。 为什么不是递归？同样是递归，只是不是沿着，而是跨越。

伊戈尔只是抱怨说，他有两个周期，不能把奇迹塞进一个周期。
所以，我想起了这个网站上的一个例子，也许我完全可以不用循环。奇迹可能会发生 ))
所以我建议采用这种方式，只是为了思考 )) 也许不用循环就能成功。
而事实上，有人什么不根据宗教，这是一个问题，每个人。

[Igor Makanu]

Roman:

伊戈尔只是抱怨他得到了两个循环，不能把奇迹塞进一个循环。

我不是在抱怨，我是想学习程序员的秘密 :)

我可以做到，我可以用递归来包裹（替换）一个循环--这样做才有意义 :)

罗马 人。

不属于宗教的东西是大家的事。

这与宗教信仰无关，而是理解有成熟的编程实践，如果大多数人使用这些实践，就意味着它们是有效的--在速度方面有效，在代码可读性 方面有效，在进一步维护方面有效，在重用方面有效......

我认为，在编程方面的知识通常是关于不拥有材料（或信息），然后将这些 "耙子 "作为你自己的创新来传播。

[Roman]

Igor Makanu:

我不是在抱怨，我是想了解程序员的秘密 :)

我可以做到，我也可以使用递归，如果这有帮助的话:)

这不是关于宗教，而是关于有成熟的编程实践的想法，如果大多数人使用它们，就意味着它们是高效的--在速度方面是高效的，在代码可读性 方面是高效的，在进一步维护方面是高效的，在重复使用方面是高效的......

而宗教呢？我认为，在编程中的诀窍通常是不拥有材料（或信息），然后将这些 "耙子 "作为自己的创新来传播。

有一个例子提到，这个例子使用了元编程模式。
使用模板，可以编写在编译时进行计算的程序，只要它适合任务。
这样的程序被称为模板元程序。
该终端被称为MetaTrader是有原因的。
;))

[Aleksey Mavrin]

Igor Makanu:

我不是在抱怨，我是想了解程序员的秘密 :)

我可以做到，我也可以使用递归，如果这有帮助的话:)

这不是关于宗教，而是关于有成熟的编程实践的想法，如果大多数人使用它们，就意味着它们是高效的--在速度方面是高效的，在代码可读性 方面是高效的，在进一步维护方面是高效的，在重复使用方面是高效的......

和宗教？我认为，在编程中的诀窍，通常不是拥有材料（或信息），然后把这些 "耙子 "作为自己的创新来传播。

伊戈尔，今天早上我忍不住了，在膝盖上画了一个没有循环的任何方法的调用。以防万一，它可能真的会派上用场。*小心翼翼地，使用了SB :))

#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];
     }
  }
//+------------------------------------------------------------------+

[Maxim Kuznetsov]

Dmitry Fedoseev:

为什么？另一种模式。除了模式的信徒不承认它，显然不是正统的，不是典范的。 为什么不是递归？这也是递归，只是不是纵向的，而是横向的。

这被称为 "循环解卷"，是由编译器完成的，不需要任何OO和模板（至少应该如此）。

如果你看一下中间代码（汇编程序），只是有N个连续的操作，而不是一个循环。

[fxsaber]

得到了一个意外的结果。

#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

[Vladimir Simakov]

fxsaber:
得到了一个意外的结果。

通过sizeof，结构的尺寸 是多少，因为我不在电脑前？

[fxsaber]

Vladimir Simakov:
通过sizeof，结构的大小 是多少，因为我不在电脑前？

        : sizeof(STRUCT1) = 20
        : sizeof(STRUCT2) = 16

简单结构的尺寸越大，处理的速度就越慢。

[Vladimir Simakov]

fxsaber:

简单结构的尺寸越大，处理的速度就越慢。

制作第一个结构{int;int;double[2]}。

[fxsaber]

Vladimir Simakov:
制作第一个结构{int;int;double[2]}。

        Alert: Time[Test6.mq5 285: Func(Array1)] = 378 ms.
        Alert: Time[Test6.mq5 286: Func(Array2)] = 156 ms.

结盟与此毫无关系。我马上检查了这一点。